CompilerType: Add ability to retrieve an integral template argument

[labath]

Summary

Despite it's name, GetTemplateArgument was only really working for Type
template arguments. This adds the ability to retrieve integral arguments
as well (which I've needed for the std::bitset data formatter).

I've done this by splitting the function into three pieces. The idea is
that one first calls GetTemplateArgumentKind (first function) to
determine the what kind of a parameter this is. Based on that, one can
then use specialized functions to retrieve the correct value. Currently,
I only implement two of these: GetTypeTemplateArgument and
GetIntegralTemplateArgument.

[labath]

source/API/SBType.cpp

422 ↗

(On Diff #122247)

I should point out that this changes the behaviour of SBType::GetTemplateArgumentType slightly.

Previously, for an integral template argument (e.g. foo<47>), it returned the *type* of the integer argument (i.e. int), where as now it will return nothing.

I think this is the behavior that makes most sense for the underlying API, but if you're worried about compatibility, I can add a special case here (I am not worried as I don't think there is anything reasonable the user could have done with the returned value anyway).

[clayborg]

Just a few changes.

• I would like the see the SBType returned for the integer template types as it is what I would expect to happen.
• we should add default implementations for stuff in TypeSystem and not require all languages to override everything. I know this isn't the way things were done in the past, but we should fix that to avoid bloat in all TypeSystem subclasses.

include/lldb/Symbol/GoASTContext.h

318–334 ↗

(On Diff #122247)

I know this isn't how things were done up to now, but we really should move these default implementations in the original class and not require everyone to override with a version that does nothing. Can we not make these pure virtual in the original class?

include/lldb/Symbol/JavaASTContext.h

206–220 ↗

(On Diff #122247)

I know this isn't how things were done up to now, but we really should move these default implementations in the original class and not require everyone to override with a version that does nothing. Can we not make these pure virtual in the original class?

include/lldb/Symbol/OCamlASTContext.h

234–248 ↗

(On Diff #122247)

I know this isn't how things were done up to now, but we really should move these default implementations in the original class and not require everyone to override with a version that does nothing. Can we not make these pure virtual in the original class?

include/lldb/Symbol/TypeSystem.h

354–360 ↗

(On Diff #122247)

Put default implementations here, and don't modify the Go, Java and OCaml ASTs?

source/API/SBType.cpp

422 ↗

(On Diff #122247)

I would like this to return the type here as I believe that makes the most sense. Why would we not return the correct type of the template argument for integers?

[clayborg]

include/lldb/Symbol/TypeSystem.h

356–360 ↗

(On Diff #122247)

Why not make three functions:

• get kind by index
• get type by index
• get integer by index

The "get integer by index" would only work if the kind was eTemplateArgumentKindIntegral? Not sure why we have the pair getter?

[labath]

In D39844#920621, @clayborg wrote:

Just a few changes.

• I would like the see the SBType returned for the integer template types as it is what I would expect to happen.

I tried to explain my reasoning in the inline comments. I don't feel strongly about that, but I do fell that makes a better API (it also mirrors what the underlying clang class does).

• we should add default implementations for stuff in TypeSystem and not require all languages to override everything. I know this isn't the way things were done in the past, but we should fix that to avoid bloat in all TypeSystem subclasses.

Good idea. Will do.

include/lldb/Symbol/TypeSystem.h

356–360 ↗

(On Diff #122247)

The second element of the pair is the *type* of the integral parameter (so you can e.g. differentiate between foo<47> and foo<47ULL>). I don't really have a use for it now, but it made sense to me to return this way (instead of through the "get type by index" function).

source/API/SBType.cpp

422 ↗

(On Diff #122247)

Well.. I am not sure what would the SBType users expect, but I looked at all the in-tree CompilerType users. All of them are data formatters and they use it to pluck the element type out of e.g. std::vector<int>.

If somebody declares a type std::vector<47> for whatever reason, we wouldn't be doing them a favor by returning int to their question "what is the first template argument?". Some of the formatters (e.g. LibCxxInitializerList) actually check that the returned kind is Type, but most of them just take the result as face value. By returning the type only if it was a type template, we are making the formatters more correct and simpler.

That was my reasoning for CompilerType. I am not really sure how SBType is used out there, but my expectation is that it will be used in a similar way as we use CompilerType. I can see the logic in the other approach as well, but right now I can't think of any situation where I'd want to treat foo<int> and foo<47> in the same way.

[zturner]

unittests/Symbol/TestClangASTContext.cpp

418–419 ↗

(On Diff #122247)

What about booleans, functions, pointers, references, parameter packs, and everything else? Even if you want to limit the scope of your change to exclude parameter packs, I think we should handle the other stuff. If it already works, can you add some tests for those cases?

[clayborg]

I see your point. But if we do ask a template parameter for its type, I would like to be able to get it's type somehow. Seems wrong to leave this out. I know it doesn't mirror clang, but we should do the right thing here. At least at the SB API layer. I am fine with leaving the new TypeSystem calls as you added them.

[labath]

unittests/Symbol/TestClangASTContext.cpp

418–419 ↗

(On Diff #122247)

I think boolean is handled as an integral type, but I can check that.

The other options here are "declaration", "template", "template expansion", "expression", "nullptr", and "pack".

Of these, I think I know what a "declaration" kind is, but I am not sure about most of the others (e.g. I don't think "expression" kind can even appear in our case, as we should always see a fully resolved template.

The thing is, there is nothing to "work" here. We have no API to retrieve and represent these entities. All you can do is call GetTemplateArgumentKind on them (which only translates between one enum and the other) and one of these two getters (which will return the empty value, because they're called on the wrong kind). I suppose I could test that.

What would be interesting is to test the other cases in the GetAsTemplateSpecialization (seeing through typedefs and stuff). This is actually the main reason why I wrote this test, as I had to refactor that code. I didn't do that, because I felt I would have to go through heroic efforts to construct e.g. a clang::Type::Elaborated object -- I don't think our ClangASTContext even has methods for constructing that.

[labath]

In D39844#920722, @clayborg wrote:

I see your point. But if we do ask a template parameter for its type, I would like to be able to get it's type somehow. Seems wrong to leave this out. I know it doesn't mirror clang, but we should do the right thing here. At least at the SB API layer. I am fine with leaving the new TypeSystem calls as you added them.

If the thing your worried about is not being able to access the type of the integral template argument, I can add a new method to SBType which would return it's value and the type, mirroring the way TypeSystem does it (it would probably have to return something through an argument, as swig would probably choke on std::pair).

[labath]

• provide default no-op implementations in TypeSystem, so derived classes don't have to override them if they don't want to
• have SBType::GetTemplateArgumentType return the type of the integral value for integral template arguments
• more tests: I have added a test to check we correctly see through the "auto" type and that the functions (correctly) return empty values when called on an argument of the wrong kind.

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

public:
   // 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;
 
-  CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                   size_t idx,
-                                   lldb::TemplateArgumentKind &kind) override;
+  lldb::TemplateArgumentKind
+  GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
+                          size_t idx) override;
+  CompilerType GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
+                                       size_t idx) override;
+  std::pair<llvm::APSInt, CompilerType>
+  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
+                              size_t idx) 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,
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
 
   clang::DeclarationName
   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
   
   virtual const clang::ExternalASTMerger::OriginMap &GetOriginMap() {
     return m_origins;
   }
 protected:
+  const clang::ClassTemplateSpecializationDecl *
+  GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
+
   //------------------------------------------------------------------
   // Classes that inherit from ClangASTContext can see and modify these
   //------------------------------------------------------------------
   // clang-format off
     std::string                                     m_target_triple;
     std::unique_ptr<clang::ASTContext>              m_ast_ap;
     std::unique_ptr<clang::LangOptions>             m_language_options_ap;
     std::unique_ptr<clang::FileManager>             m_file_manager_ap;

lldb/trunk/include/lldb/Symbol/CompilerType.h

public:
   // 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;
 
-  CompilerType GetTemplateArgument(size_t idx,
-                                   lldb::TemplateArgumentKind &kind) const;
+  lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
+  CompilerType GetTypeTemplateArgument(size_t idx) const;
+
+  // Returns the value of the template argument and its type. In case the
+  // argument is not found, returns an invalid CompilerType.
+  std::pair<llvm::APSInt, CompilerType> GetIntegralTemplateArgument(size_t idx) const;
 
   CompilerType GetTypeForFormatters() const;
 
   LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
 
   bool IsMeaninglessWithoutDynamicResolution() const;
 
   //------------------------------------------------------------------

lldb/trunk/include/lldb/Symbol/GoASTContext.h

public:
   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 {
     return 0;
   }
 
-  CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                   size_t idx,
-                                   lldb::TemplateArgumentKind &kind) override {
-    return CompilerType();
-  }
-
   //----------------------------------------------------------------------
   // 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,
                  bool show_types, bool show_summary, bool verbose,

lldb/trunk/include/lldb/Symbol/JavaASTContext.h

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;
 
-  CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                   size_t idx,
-                                   lldb::TemplateArgumentKind &kind) 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;
 

lldb/trunk/include/lldb/Symbol/OCamlASTContext.h

public:
   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 {
     return 0;
   }
 
-  CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                   size_t idx,
-                                   lldb::TemplateArgumentKind &kind) override {
-    return CompilerType();
-  }
-
   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;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,

lldb/trunk/include/lldb/Symbol/TypeSystem.h

public:
   // 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 CompilerType
-  GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
-                      lldb::TemplateArgumentKind &kind) = 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);
+  virtual std::pair<llvm::APSInt, CompilerType>
+  GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
+                              size_t idx);
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
 
   virtual void DumpValue(lldb::opaque_compiler_type_t type,
                          ExecutionContext *exe_ctx, Stream *s,
                          lldb::Format format, const DataExtractor &data,

lldb/trunk/include/lldb/lldb-enumerations.h

 enum TemplateArgumentKind {
   eTemplateArgumentKindNull = 0,
   eTemplateArgumentKindType,
   eTemplateArgumentKindDeclaration,
   eTemplateArgumentKindIntegral,
   eTemplateArgumentKindTemplate,
   eTemplateArgumentKindTemplateExpansion,
   eTemplateArgumentKindExpression,
-  eTemplateArgumentKindPack
-
+  eTemplateArgumentKindPack,
+  eTemplateArgumentKindNullPtr,
 };
 
 //----------------------------------------------------------------------
 // Options that can be set for a formatter to alter its behavior
 // Not all of these are applicable to all formatter types
 //----------------------------------------------------------------------
 FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
                         eTypeOptionCascade = (1u << 0),

lldb/trunk/source/API/SBType.cpp

 
 uint32_t SBType::GetNumberOfTemplateArguments() {
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
   return 0;
 }
 
 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
-  if (IsValid()) {
-    TemplateArgumentKind kind = eTemplateArgumentKindNull;
-    CompilerType template_arg_type =
-        m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind);
-    if (template_arg_type.IsValid())
-      return SBType(template_arg_type);
+  if (!IsValid())
+    return SBType();
+
+  CompilerType type;
+  switch(GetTemplateArgumentKind(idx)) {
+    case eTemplateArgumentKindType:
+      type = m_opaque_sp->GetCompilerType(false).GetTypeTemplateArgument(idx);
+      break;
+    case eTemplateArgumentKindIntegral:
+      type = m_opaque_sp->GetCompilerType(false)
+                 .GetIntegralTemplateArgument(idx)
+                 .second;
+      break;
+    default:
+      break;
   }
+  if (type.IsValid())
+    return SBType(type);
   return SBType();
 }
 
 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
-  TemplateArgumentKind kind = eTemplateArgumentKindNull;
   if (IsValid())
-    m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind);
-  return kind;
+    return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(idx);
+  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();
        i < rhs_size; i++)

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.cpp

m_pair_ptr = valobj_sp
                              .DontCheckDotVsArrowSyntax()
                              .SetSyntheticChildrenTraversal(
                                  ValueObject::GetValueForExpressionPathOptions::
                                      SyntheticChildrenTraversal::None),
                          nullptr)
                      .get();
     if (m_pair_ptr) {
       auto __i_(valobj_sp->GetChildMemberWithName(g___i_, true));
-      lldb::TemplateArgumentKind kind;
       if (!__i_) {
         m_pair_ptr = nullptr;
         return false;
       }
-      CompilerType pair_type(__i_->GetCompilerType().GetTemplateArgument(0, kind));
+      CompilerType pair_type(__i_->GetCompilerType().GetTypeTemplateArgument(0));
       std::string name; uint64_t bit_offset_ptr; uint32_t bitfield_bit_size_ptr; bool is_bitfield_ptr;
       pair_type = pair_type.GetFieldAtIndex(0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
       if (!pair_type) {
         m_pair_ptr = nullptr;
         return false;
       }
       
       auto addr(m_pair_ptr->GetValueAsUnsigned(LLDB_INVALID_ADDRESS));

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     Update() {
   static ConstString g___begin_("__begin_");
 
   m_start = nullptr;
   m_num_elements = 0;
-  lldb::TemplateArgumentKind kind;
-  m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind);
-  if (kind != lldb::eTemplateArgumentKindType || !m_element_type.IsValid())
+  m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
+  if (!m_element_type.IsValid())
     return false;
 
   m_element_size = m_element_type.GetByteSize(nullptr);
 
   if (m_element_size > 0)
     m_start =
         m_backend.GetChildMemberWithName(g___begin_, true)
             .get(); // store raw pointers or end up with a circular dependency

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

if (m_list_capping_size == 0)
     m_list_capping_size = 255;
 
   CompilerType list_type = m_backend.GetCompilerType();
   if (list_type.IsReferenceType())
     list_type = list_type.GetNonReferenceType();
 
   if (list_type.GetNumTemplateArguments() == 0)
     return false;
-  TemplateArgumentKind kind;
-  m_element_type = list_type.GetTemplateArgument(0, kind);
+  m_element_type = list_type.GetTypeTemplateArgument(0);
 
   return false;
 }
 
 bool AbstractListFrontEnd::HasLoop(size_t count) {
   if (!g_use_loop_detect)
     return false;
   // don't bother checking for a loop if we won't actually need to jump nodes

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
   deref = m_root_node->Dereference(error);
   if (!deref || error.Fail())
     return false;
   deref = deref->GetChildMemberWithName(g___value_, true);
   if (deref) {
     m_element_type = deref->GetCompilerType();
     return true;
   }
-  lldb::TemplateArgumentKind kind;
   deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3});
   if (!deref)
     return false;
-  m_element_type =
-      deref->GetCompilerType().GetTemplateArgument(1, kind).GetTemplateArgument(
-          1, kind);
+  m_element_type = deref->GetCompilerType()
+                       .GetTypeTemplateArgument(1)
+                       .GetTypeTemplateArgument(1);
   if (m_element_type) {
     std::string name;
     uint64_t bit_offset_ptr;
     uint32_t bitfield_bit_size_ptr;
     bool is_bitfield_ptr;
     m_element_type = m_element_type.GetFieldAtIndex(
         0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
     m_element_type = m_element_type.GetTypedefedType();
     return m_element_type.IsValid();
   } else {
-    m_element_type = m_backend.GetCompilerType().GetTemplateArgument(0, kind);
+    m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
     return m_element_type.IsValid();
   }
 }
 
 void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
     const lldb::ValueObjectSP &node) {
   if (m_skip_size != UINT32_MAX)
     return;

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

if (!hash_sp || !value_sp) {
         }
         default:
           return nullptr;
         }
 
         if (!first_sp)
           return nullptr;
         m_element_type = first_sp->GetCompilerType();
-        lldb::TemplateArgumentKind kind;
-        m_element_type = m_element_type.GetTemplateArgument(0, kind);
+        m_element_type = m_element_type.GetTypeTemplateArgument(0);
         m_element_type = m_element_type.GetPointeeType();
         m_node_type = m_element_type;
-        m_element_type = m_element_type.GetTemplateArgument(0, kind);
+        m_element_type = m_element_type.GetTypeTemplateArgument(0);
         std::string name;
         m_element_type =
             m_element_type.GetFieldAtIndex(0, name, nullptr, nullptr, nullptr);
         m_element_type = m_element_type.GetTypedefedType();
       }
       if (!m_node_type)
         return nullptr;
       node_sp = node_sp->Cast(m_node_type);

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

 lldb_private::SyntheticChildrenFrontEnd *
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   if (!valobj_sp)
     return nullptr;
   CompilerType type = valobj_sp->GetCompilerType();
   if (!type.IsValid() || type.GetNumTemplateArguments() == 0)
     return nullptr;
-  TemplateArgumentKind kind;
-  CompilerType arg_type = type.GetTemplateArgument(0, kind);
+  CompilerType arg_type = type.GetTypeTemplateArgument(0);
   if (arg_type.GetTypeName() == ConstString("bool"))
     return new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp);
   return new LibcxxStdVectorSyntheticFrontEnd(valobj_sp);
 }

lldb/trunk/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

bool LibstdcppMapIteratorSyntheticFrontEnd::Update() {
   m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
   if (m_pair_address == 0)
     return false;
 
   m_pair_address += (is_64bit ? 32 : 16);
 
   CompilerType my_type(valobj_sp->GetCompilerType());
   if (my_type.GetNumTemplateArguments() >= 1) {
-    TemplateArgumentKind kind;
-    CompilerType pair_type = my_type.GetTemplateArgument(0, kind);
-    if (kind != eTemplateArgumentKindType &&
-        kind != eTemplateArgumentKindTemplate &&
-        kind != eTemplateArgumentKindTemplateExpansion)
+    CompilerType pair_type = my_type.GetTypeTemplateArgument(0);
+    if (!pair_type)
       return false;
     m_pair_type = pair_type;
   } else
     return false;
 
   return true;
 }
 

lldb/trunk/source/Symbol/ClangASTContext.cpp

ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
 
   default:
     break;
   }
 
   return 0;
 }
 
-CompilerType
-ClangASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                     size_t arg_idx,
-                                     lldb::TemplateArgumentKind &kind) {
+const clang::ClassTemplateSpecializationDecl *
+ClangASTContext::GetAsTemplateSpecialization(
+    lldb::opaque_compiler_type_t type) {
   if (!type)
-    return CompilerType();
+    return nullptr;
 
   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 &&
-            arg_idx < template_decl->getTemplateArgs().size()) {
-          const clang::TemplateArgument &template_arg =
-              template_decl->getTemplateArgs()[arg_idx];
-          switch (template_arg.getKind()) {
-          case clang::TemplateArgument::Null:
-            kind = eTemplateArgumentKindNull;
-            return CompilerType();
+  case clang::Type::Record: {
+    if (! GetCompleteType(type))
+      return nullptr;
+    if (!cxx_record_decl)
+      return nullptr;
+    return llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
+  }
+
+  case clang::Type::Typedef:
+    return GetAsTemplateSpecialization(llvm::cast<clang::TypedefType>(qual_type)
+                                           ->getDecl()
+                                           ->getUnderlyingType()
+                                           .getAsOpaquePtr());
+
+  case clang::Type::Auto:
+    return GetAsTemplateSpecialization(llvm::cast<clang::AutoType>(qual_type)
+                                           ->getDeducedType()
+                                           .getAsOpaquePtr());
+
+  case clang::Type::Elaborated:
+    return GetAsTemplateSpecialization(
+        llvm::cast<clang::ElaboratedType>(qual_type)
+            ->getNamedType()
+            .getAsOpaquePtr());
+
+  case clang::Type::Paren:
+    return GetAsTemplateSpecialization(
+        llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
+
+  default:
+    return nullptr;
+  }
+}
+
+lldb::TemplateArgumentKind
+ClangASTContext::GetTemplateArgumentKind(lldb::opaque_compiler_type_t type,
+                                         size_t arg_idx) {
+  const clang::ClassTemplateSpecializationDecl *template_decl =
+      GetAsTemplateSpecialization(type);
+  if (! template_decl || arg_idx >= template_decl->getTemplateArgs().size())
+    return eTemplateArgumentKindNull;
+
+  switch (template_decl->getTemplateArgs()[arg_idx].getKind()) {
+    return eTemplateArgumentKindNull;
+
+  case clang::TemplateArgument::NullPtr:
+    return eTemplateArgumentKindNullPtr;
 
-          case clang::TemplateArgument::Type:
-            kind = eTemplateArgumentKindType;
-            return CompilerType(getASTContext(), template_arg.getAsType());
+    return eTemplateArgumentKindType;
 
-          case clang::TemplateArgument::Declaration:
-            kind = eTemplateArgumentKindDeclaration;
-            return CompilerType();
+    return eTemplateArgumentKindDeclaration;
 
-          case clang::TemplateArgument::Integral:
-            kind = eTemplateArgumentKindIntegral;
-            return CompilerType(getASTContext(),
-                                template_arg.getIntegralType());
+    return eTemplateArgumentKindIntegral;
 
-          case clang::TemplateArgument::Template:
-            kind = eTemplateArgumentKindTemplate;
-            return CompilerType();
+    return eTemplateArgumentKindTemplate;
 
-          case clang::TemplateArgument::TemplateExpansion:
-            kind = eTemplateArgumentKindTemplateExpansion;
-            return CompilerType();
+    return eTemplateArgumentKindTemplateExpansion;
 
-          case clang::TemplateArgument::Expression:
-            kind = eTemplateArgumentKindExpression;
-            return CompilerType();
+    return eTemplateArgumentKindExpression;
 
-          case clang::TemplateArgument::Pack:
-            kind = eTemplateArgumentKindPack;
-            return CompilerType();
-
-          default:
-            llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind");
-          }
-        }
-      }
-    }
-    break;
+    return eTemplateArgumentKindPack;
+  llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind");
 
-  case clang::Type::Typedef:
-    return (CompilerType(getASTContext(),
-                         llvm::cast<clang::TypedefType>(qual_type)
-                             ->getDecl()
-                             ->getUnderlyingType()))
-        .GetTemplateArgument(arg_idx, kind);
+CompilerType
+ClangASTContext::GetTypeTemplateArgument(lldb::opaque_compiler_type_t type,
+                                         size_t idx) {
+  const clang::ClassTemplateSpecializationDecl *template_decl =
+      GetAsTemplateSpecialization(type);
+  if (!template_decl || idx >= template_decl->getTemplateArgs().size())
+    return CompilerType();
 
-  case clang::Type::Auto:
-    return (CompilerType(
-                getASTContext(),
-                llvm::cast<clang::AutoType>(qual_type)->getDeducedType()))
-        .GetTemplateArgument(arg_idx, kind);
+  const clang::TemplateArgument &template_arg =
+      template_decl->getTemplateArgs()[idx];
+  if (template_arg.getKind() != clang::TemplateArgument::Type)
+    return CompilerType();
 
-  case clang::Type::Elaborated:
-    return (CompilerType(
-                getASTContext(),
-                llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()))
-        .GetTemplateArgument(arg_idx, kind);
+  return CompilerType(getASTContext(), template_arg.getAsType());
+}
 
-  case clang::Type::Paren:
-    return (CompilerType(getASTContext(),
-                         llvm::cast<clang::ParenType>(qual_type)->desugar()))
-        .GetTemplateArgument(arg_idx, kind);
+std::pair<llvm::APSInt, CompilerType>
+ClangASTContext::GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type,
+                                             size_t idx) {
+  const clang::ClassTemplateSpecializationDecl *template_decl =
+      GetAsTemplateSpecialization(type);
+  if (! template_decl || idx >= template_decl->getTemplateArgs().size())
+    return {llvm::APSInt(0), CompilerType()};
 
-  default:
-    break;
-  }
-  kind = eTemplateArgumentKindNull;
-  return CompilerType();
+  const clang::TemplateArgument &template_arg =
+      template_decl->getTemplateArgs()[idx];
+  if (template_arg.getKind() != clang::TemplateArgument::Integral)
+    return {llvm::APSInt(0), CompilerType()};
+
+  return {template_arg.getAsIntegral(),
+          CompilerType(getASTContext(), template_arg.getIntegralType())};
 }
 
 CompilerType ClangASTContext::GetTypeForFormatters(void *type) {
   if (type)
     return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
   return CompilerType();
 }
 

lldb/trunk/source/Symbol/CompilerType.cpp

 
 size_t CompilerType::GetNumTemplateArguments() const {
   if (IsValid()) {
     return m_type_system->GetNumTemplateArguments(m_type);
   }
   return 0;
 }
 
-CompilerType
-CompilerType::GetTemplateArgument(size_t idx,
-                                  lldb::TemplateArgumentKind &kind) const {
+TemplateArgumentKind CompilerType::GetTemplateArgumentKind(size_t idx) const {
+  if (IsValid())
+    return m_type_system->GetTemplateArgumentKind(m_type, idx);
+  return eTemplateArgumentKindNull;
+}
+
+CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const {
   if (IsValid()) {
-    return m_type_system->GetTemplateArgument(m_type, idx, kind);
+    return m_type_system->GetTypeTemplateArgument(m_type, idx);
   }
   return CompilerType();
 }
 
+std::pair<llvm::APSInt, CompilerType>
+CompilerType::GetIntegralTemplateArgument(size_t idx) const
+{
+  if (IsValid())
+    return m_type_system->GetIntegralTemplateArgument(m_type, idx);
+  return {llvm::APSInt(0), CompilerType()};
+}
+
 CompilerType CompilerType::GetTypeForFormatters() const {
   if (IsValid())
     return m_type_system->GetTypeForFormatters(m_type);
   return CompilerType();
 }
 
 LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const {
   if (IsValid())

lldb/trunk/source/Symbol/JavaASTContext.cpp

JavaASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
   return 0;
 }
 
 size_t
 JavaASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
   return 0;
 }
 
-CompilerType
-JavaASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type,
-                                    size_t idx,
-                                    lldb::TemplateArgumentKind &kind) {
-  return CompilerType();
-}
-
 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;
 }

lldb/trunk/source/Symbol/TypeSystem.cpp

 #include "lldb/Symbol/TypeSystem.h"
 
 #include <set>
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompilerType.h"
 
 using namespace lldb_private;
+using namespace lldb;
 
 TypeSystem::TypeSystem(LLVMCastKind kind) : m_kind(kind), m_sym_file(nullptr) {}
 
 TypeSystem::~TypeSystem() {}
 
 static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
                                                Module *module, Target *target) {
   uint32_t i = 0;

 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) {
+  return eTemplateArgumentKindNull;
+}
+
+CompilerType TypeSystem::GetTypeTemplateArgument(opaque_compiler_type_t type,
+                                                 size_t idx) {
+  return CompilerType();
+}
+
+std::pair<llvm::APSInt, CompilerType>
+TypeSystem::GetIntegralTemplateArgument(opaque_compiler_type_t type,
+                            size_t idx) {
+  return {llvm::APSInt(0), CompilerType()};
+}
+
 LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) {
   return eLazyBoolCalculate;
 }
 
 bool TypeSystem::IsMeaninglessWithoutDynamicResolution(void *type) {
   return false;
 }
 

lldb/trunk/unittests/Symbol/TestClangASTContext.cpp

TEST_F(TestClangASTContext, TemplateArguments) {
   m_ast->StartTagDeclarationDefinition(type);
   m_ast->CompleteTagDeclarationDefinition(type);
 
   // typedef foo<int, 47> foo_def;
   CompilerType typedef_type = m_ast->CreateTypedefType(
       type, "foo_def",
       CompilerDeclContext(m_ast.get(), m_ast->GetTranslationUnitDecl()));
 
+  CompilerType auto_type(m_ast->getASTContext(),
+                         m_ast->getASTContext()->getAutoType(
+                             ClangUtil::GetCanonicalQualType(typedef_type),
+                             clang::AutoTypeKeyword::Auto, false));
+
   CompilerType int_type(m_ast->getASTContext(), m_ast->getASTContext()->IntTy);
-  for(CompilerType t: { type, typedef_type }) {
+  for(CompilerType t: { type, typedef_type, auto_type }) {
     SCOPED_TRACE(t.GetTypeName().AsCString());
-    TemplateArgumentKind kind;
 
-    CompilerType arg =
-        m_ast->GetTemplateArgument(t.GetOpaqueQualType(), 0, kind);
-    EXPECT_EQ(kind, eTemplateArgumentKindType);
-    EXPECT_EQ(arg, int_type);
-
-    arg = m_ast->GetTemplateArgument(t.GetOpaqueQualType(), 1, kind);
-    EXPECT_EQ(kind, eTemplateArgumentKindIntegral);
-    EXPECT_EQ(arg, int_type);
+    EXPECT_EQ(m_ast->GetTemplateArgumentKind(t.GetOpaqueQualType(), 0),
+              eTemplateArgumentKindType);
+    EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 0),
+              int_type);
+    auto p = m_ast->GetIntegralTemplateArgument(t.GetOpaqueQualType(), 0);
+    EXPECT_EQ(p.second, CompilerType());
+
+    EXPECT_EQ(m_ast->GetTemplateArgumentKind(t.GetOpaqueQualType(), 1),
+              eTemplateArgumentKindIntegral);
+    EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 1),
+              CompilerType());
+    p = m_ast->GetIntegralTemplateArgument(t.GetOpaqueQualType(), 1);
+    EXPECT_EQ(p.first, llvm::APSInt(47));
+    EXPECT_EQ(p.second, int_type);
   }
 }