diff options
20 files changed, 211 insertions, 155 deletions
diff --git a/lldb/include/lldb/Symbol/ClangASTContext.h b/lldb/include/lldb/Symbol/ClangASTContext.h index 5a68f5e077c..e97f3a094d4 100644 --- a/lldb/include/lldb/Symbol/ClangASTContext.h +++ b/lldb/include/lldb/Symbol/ClangASTContext.h @@ -782,9 +782,14 @@ public: 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; @@ -971,6 +976,9 @@ public: return m_origins; } protected: + const clang::ClassTemplateSpecializationDecl * + GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type); + //------------------------------------------------------------------ // Classes that inherit from ClangASTContext can see and modify these //------------------------------------------------------------------ diff --git a/lldb/include/lldb/Symbol/CompilerType.h b/lldb/include/lldb/Symbol/CompilerType.h index c5bca54ed43..bac6e44926d 100644 --- a/lldb/include/lldb/Symbol/CompilerType.h +++ b/lldb/include/lldb/Symbol/CompilerType.h @@ -365,8 +365,12 @@ public: 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; diff --git a/lldb/include/lldb/Symbol/GoASTContext.h b/lldb/include/lldb/Symbol/GoASTContext.h index 6feac7abf16..ee111942c20 100644 --- a/lldb/include/lldb/Symbol/GoASTContext.h +++ b/lldb/include/lldb/Symbol/GoASTContext.h @@ -315,12 +315,6 @@ public: return 0; } - CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type, - size_t idx, - lldb::TemplateArgumentKind &kind) override { - return CompilerType(); - } - //---------------------------------------------------------------------- // Dumping types //---------------------------------------------------------------------- diff --git a/lldb/include/lldb/Symbol/JavaASTContext.h b/lldb/include/lldb/Symbol/JavaASTContext.h index 4fdd2371b67..41a881dcf4e 100644 --- a/lldb/include/lldb/Symbol/JavaASTContext.h +++ b/lldb/include/lldb/Symbol/JavaASTContext.h @@ -203,10 +203,6 @@ public: 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, diff --git a/lldb/include/lldb/Symbol/OCamlASTContext.h b/lldb/include/lldb/Symbol/OCamlASTContext.h index a261d43519e..7144886e1c7 100644 --- a/lldb/include/lldb/Symbol/OCamlASTContext.h +++ b/lldb/include/lldb/Symbol/OCamlASTContext.h @@ -231,12 +231,6 @@ public: 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, diff --git a/lldb/include/lldb/Symbol/TypeSystem.h b/lldb/include/lldb/Symbol/TypeSystem.h index b4f84c0dd67..440f3a43edf 100644 --- a/lldb/include/lldb/Symbol/TypeSystem.h +++ b/lldb/include/lldb/Symbol/TypeSystem.h @@ -351,9 +351,13 @@ public: 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 diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index 1bf3b56a7fc..760e12b0e79 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -767,8 +767,8 @@ enum TemplateArgumentKind { eTemplateArgumentKindTemplate, eTemplateArgumentKindTemplateExpansion, eTemplateArgumentKindExpression, - eTemplateArgumentKindPack - + eTemplateArgumentKindPack, + eTemplateArgumentKindNullPtr, }; //---------------------------------------------------------------------- diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp index e2ef07cf5c4..b0357da5c57 100644 --- a/lldb/source/API/SBType.cpp +++ b/lldb/source/API/SBType.cpp @@ -415,21 +415,31 @@ uint32_t SBType::GetNumberOfTemplateArguments() { } 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()) {} diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp index 11245e1310b..f6d1f18cb59 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp @@ -153,12 +153,11 @@ bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() { .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) { diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp index 4e839532afb..5823f6f3e03 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp @@ -94,9 +94,8 @@ bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: 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); diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp index 3a8bc2087f8..6407ae129ad 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp @@ -192,8 +192,7 @@ bool AbstractListFrontEnd::Update() { 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; } diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp index b7215dbcbb4..be96a6d95bc 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp @@ -268,13 +268,12 @@ bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() { 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; @@ -285,7 +284,7 @@ bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() { 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(); } } diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp index 190b5f64381..0f1c2537d65 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp @@ -121,11 +121,10 @@ lldb::ValueObjectSP lldb_private::formatters:: 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); diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp index 6f601c9f6cc..711130639cd 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp @@ -290,8 +290,7 @@ lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator( 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); diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp index e3018a1884b..3e2b7159f89 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp @@ -117,11 +117,8 @@ bool LibstdcppMapIteratorSyntheticFrontEnd::Update() { 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 diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 7d87a8ae2f8..ac16f91285c 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -7549,99 +7549,122 @@ ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) { 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::TemplateArgument::Type: - kind = eTemplateArgumentKindType; - return CompilerType(getASTContext(), template_arg.getAsType()); - - case clang::TemplateArgument::Declaration: - kind = eTemplateArgumentKindDeclaration; - return CompilerType(); - - case clang::TemplateArgument::Integral: - kind = eTemplateArgumentKindIntegral; - return CompilerType(getASTContext(), - template_arg.getIntegralType()); - - case clang::TemplateArgument::Template: - kind = eTemplateArgumentKindTemplate; - return CompilerType(); - - case clang::TemplateArgument::TemplateExpansion: - kind = eTemplateArgumentKindTemplateExpansion; - return CompilerType(); - - case clang::TemplateArgument::Expression: - kind = eTemplateArgumentKindExpression; - return CompilerType(); - - case clang::TemplateArgument::Pack: - kind = eTemplateArgumentKindPack; - return CompilerType(); - - default: - llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind"); - } - } - } - } - break; + case clang::Type::Record: { + if (! GetCompleteType(type)) + return nullptr; + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (!cxx_record_decl) + return nullptr; + return llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>( + cxx_record_decl); + } case clang::Type::Typedef: - return (CompilerType(getASTContext(), - llvm::cast<clang::TypedefType>(qual_type) - ->getDecl() - ->getUnderlyingType())) - .GetTemplateArgument(arg_idx, kind); + return GetAsTemplateSpecialization(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); case clang::Type::Auto: - return (CompilerType( - getASTContext(), - llvm::cast<clang::AutoType>(qual_type)->getDeducedType())) - .GetTemplateArgument(arg_idx, kind); + return GetAsTemplateSpecialization(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); case clang::Type::Elaborated: - return (CompilerType( - getASTContext(), - llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())) - .GetTemplateArgument(arg_idx, kind); + return GetAsTemplateSpecialization( + llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); case clang::Type::Paren: - return (CompilerType(getASTContext(), - llvm::cast<clang::ParenType>(qual_type)->desugar())) - .GetTemplateArgument(arg_idx, kind); + return GetAsTemplateSpecialization( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); default: - break; + return nullptr; } - kind = eTemplateArgumentKindNull; - return CompilerType(); +} + +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()) { + case clang::TemplateArgument::Null: + return eTemplateArgumentKindNull; + + case clang::TemplateArgument::NullPtr: + return eTemplateArgumentKindNullPtr; + + case clang::TemplateArgument::Type: + return eTemplateArgumentKindType; + + case clang::TemplateArgument::Declaration: + return eTemplateArgumentKindDeclaration; + + case clang::TemplateArgument::Integral: + return eTemplateArgumentKindIntegral; + + case clang::TemplateArgument::Template: + return eTemplateArgumentKindTemplate; + + case clang::TemplateArgument::TemplateExpansion: + return eTemplateArgumentKindTemplateExpansion; + + case clang::TemplateArgument::Expression: + return eTemplateArgumentKindExpression; + + case clang::TemplateArgument::Pack: + return eTemplateArgumentKindPack; + } + llvm_unreachable("Unhandled clang::TemplateArgument::ArgKind"); +} + +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(); + + const clang::TemplateArgument &template_arg = + template_decl->getTemplateArgs()[idx]; + if (template_arg.getKind() != clang::TemplateArgument::Type) + return CompilerType(); + + return CompilerType(getASTContext(), template_arg.getAsType()); +} + +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()}; + + 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) { diff --git a/lldb/source/Symbol/CompilerType.cpp b/lldb/source/Symbol/CompilerType.cpp index 16bb534df42..6747c051a94 100644 --- a/lldb/source/Symbol/CompilerType.cpp +++ b/lldb/source/Symbol/CompilerType.cpp @@ -690,15 +690,27 @@ size_t CompilerType::GetNumTemplateArguments() const { 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); diff --git a/lldb/source/Symbol/JavaASTContext.cpp b/lldb/source/Symbol/JavaASTContext.cpp index 4260f497d90..ba4375dcdfd 100644 --- a/lldb/source/Symbol/JavaASTContext.cpp +++ b/lldb/source/Symbol/JavaASTContext.cpp @@ -884,13 +884,6 @@ 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))) { diff --git a/lldb/source/Symbol/TypeSystem.cpp b/lldb/source/Symbol/TypeSystem.cpp index 4a9fb536fc2..ada9b4e2179 100644 --- a/lldb/source/Symbol/TypeSystem.cpp +++ b/lldb/source/Symbol/TypeSystem.cpp @@ -23,6 +23,7 @@ #include "lldb/Symbol/CompilerType.h" using namespace lldb_private; +using namespace lldb; TypeSystem::TypeSystem(LLVMCastKind kind) : m_kind(kind), m_sym_file(nullptr) {} @@ -100,6 +101,22 @@ 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; } diff --git a/lldb/unittests/Symbol/TestClangASTContext.cpp b/lldb/unittests/Symbol/TestClangASTContext.cpp index 2b4330d82c2..52b8b5392ff 100644 --- a/lldb/unittests/Symbol/TestClangASTContext.cpp +++ b/lldb/unittests/Symbol/TestClangASTContext.cpp @@ -406,18 +406,28 @@ TEST_F(TestClangASTContext, TemplateArguments) { 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); } } |
