[WIP][lldb] Add support for DW_AT_default_value in template params

[Michael137]

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

428

Could instead change names into SmallVector<ArgumentInfo> where

struct ArgumentInfo {
    char const* name = nullptr;
    bool is_default = false;
};

So any future flags don't need to be separate vectors.

[Michael137]

• Rebase

[Michael137]

• Fix API tests

[Michael137]

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

1432

Problem is currently that LLDB currently can't reconstruct a generic ClassTemplateDecl from DWARF because we only have information about instantiations. Instead we re-use the decls we constructed from the first instantiation we encountered. With this patch we would set the ClassTemplateDecl default parameter to a concrete type which isn't quite correct because the TypePrinter asks the ClassTemplateDecl for the generic default parameter and checks the instantiations arguments for substitutability. So to make this work we either:

1. Have to teach dwarf about generic parameters
2. Store the fact that a template argument corresponds to a default value somewhere in Clang

[Michael137]

• Rebase on top of work-in-progress clang changes

[Michael137]

Abandoning in favour of https://reviews.llvm.org/D141828

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.h

 #include <memory>
 #include <set>
 #include <vector>
 
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/lldb-types.h"
 
public:
   /// system of src_type can safely be deleted after calling this function.
   /// \see ClangASTImporter::CopyType
   CompilerType DeportType(TypeSystemClang &dst, const CompilerType &src_type);
 
   /// Copies the given decl to the destination type system.
   /// \see ClangASTImporter::DeportType
   clang::Decl *DeportDecl(clang::ASTContext *dst_ctx, clang::Decl *decl);
 
+  clang::PrintingCallbacks::TriState
+  IsTemplateArgumentDefaulted(clang::ClassTemplateSpecializationDecl const *D,
+                              size_t ArgIndex) const;
+
+  void
+  SetTemplateArgumentDefaults(clang::ClassTemplateSpecializationDecl const *D,
+                              llvm::BitVector defaults) {
+    m_template_decl_defaults_map[D] = std::move(defaults);
+  }
+
   /// Sets the layout for the given RecordDecl. The layout will later be
   /// used by Clang's during code generation. Not calling this function for
   /// a RecordDecl will cause that Clang's codegen tries to layout the
   /// record by itself.
   ///
   /// \param decl The RecordDecl to set the layout for.
   /// \param layout The layout for the record.
   void SetRecordLayout(clang::RecordDecl *decl, const LayoutInfo &layout);
public:
 
   DeclOrigin GetDeclOrigin(const clang::Decl *decl);
 
   clang::FileManager m_file_manager;
   typedef llvm::DenseMap<const clang::RecordDecl *, LayoutInfo>
       RecordDeclToLayoutMap;
 
   RecordDeclToLayoutMap m_record_decl_to_layout_map;
+
+  llvm::DenseMap<clang::ClassTemplateSpecializationDecl const *,
+                 llvm::BitVector>
+      m_template_decl_defaults_map;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGASTIMPORTER_H

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.cpp

void ClangASTImporter::ForgetSource(clang::ASTContext *dst_ast,
 
   if (!md)
     return;
 
   md->m_delegates.erase(src_ast);
   md->removeOriginsWithContext(src_ast);
 }
 
+PrintingCallbacks::TriState ClangASTImporter::IsTemplateArgumentDefaulted(
+    clang::ClassTemplateSpecializationDecl const *D, size_t ArgIndex) const {
+  using TriState = PrintingCallbacks::TriState;
+
+  auto it = m_template_decl_defaults_map.find(D);
+  if (it == m_template_decl_defaults_map.end())
+    return TriState::kUnknown;
+
+  auto const &bits = it->getSecond();
+  assert(bits.size() > ArgIndex);
+
+  return bits.test(ArgIndex) ? TriState::kYes : TriState::kNo;
+}
+
 ClangASTImporter::MapCompleter::~MapCompleter() = default;
 
 llvm::Expected<Decl *>
 ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) {
   if (m_std_handler) {
     llvm::Optional<Decl *> D = m_std_handler->Import(From);
     if (D) {
       // Make sure we don't use this decl later to map it back to it's original

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

if (ParseTemplateParameterInfos(die, template_param_infos)) {
         }
         return TypeSP();
       }
 
       clang::ClassTemplateSpecializationDecl *class_specialization_decl =
           m_ast.CreateClassTemplateSpecializationDecl(
               decl_ctx, GetOwningClangModule(die), class_template_decl,
               tag_decl_kind, template_param_infos);
+
+      llvm::BitVector defaults(template_param_infos.Size(), false);
+      for (size_t i = 0; i < template_param_infos.Size(); ++i)
+        defaults[i] = template_param_infos.IsDefaultArg(i);
+
+      if (!defaults.empty())
+        GetClangASTImporter().SetTemplateArgumentDefaults(
+            class_specialization_decl, std::move(defaults));
+
       clang_type = m_ast.CreateClassTemplateSpecializationType(
           class_specialization_decl);
       clang_type_was_created = true;
 
       m_ast.SetMetadata(class_template_decl, metadata);
       m_ast.SetMetadata(class_specialization_decl, metadata);
     }
 
bool DWARFASTParserClang::ParseTemplateDIE(
   case DW_TAG_template_value_parameter: {
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     const char *name = nullptr;
     const char *template_name = nullptr;
     CompilerType clang_type;
     uint64_t uval64 = 0;
     bool uval64_valid = false;
+    bool is_default_template_arg = false;
     if (num_attributes > 0) {
       DWARFFormValue form_value;
       for (size_t i = 0; i < num_attributes; ++i) {
         const dw_attr_t attr = attributes.AttributeAtIndex(i);
 
         switch (attr) {
         case DW_AT_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
if (num_attributes > 0) {
           break;
 
         case DW_AT_const_value:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             uval64_valid = true;
             uval64 = form_value.Unsigned();
           }
           break;
+        case DW_AT_default_value:
+          if (attributes.ExtractFormValueAtIndex(i, form_value)) {
+            is_default_template_arg = form_value.Boolean();
+          }
+          break;
         default:
           break;
         }
       }
 
       clang::ASTContext &ast = m_ast.getASTContext();
       if (!clang_type)
         clang_type = m_ast.GetBasicType(eBasicTypeVoid);
if (num_attributes > 0) {
         if (tag == DW_TAG_template_value_parameter && uval64_valid) {
           llvm::Optional<uint64_t> size = clang_type.GetBitSize(nullptr);
           if (!size)
             return false;
           llvm::APInt apint(*size, uval64, is_signed);
           template_param_infos.InsertArg(
               name,
               clang::TemplateArgument(ast, llvm::APSInt(apint, !is_signed),
-                                      ClangUtil::GetQualType(clang_type)));
+                                      ClangUtil::GetQualType(clang_type)),
+              is_default_template_arg);
         } else {
           template_param_infos.InsertArg(
-              name,
-              clang::TemplateArgument(ClangUtil::GetQualType(clang_type)));
+              name, clang::TemplateArgument(ClangUtil::GetQualType(clang_type)),
+              is_default_template_arg);
         }
       } else {
         auto *tplt_type = m_ast.CreateTemplateTemplateParmDecl(template_name);
         template_param_infos.InsertArg(
-            name, clang::TemplateArgument(clang::TemplateName(tplt_type)));
+            name, clang::TemplateArgument(clang::TemplateName(tplt_type)),
+            is_default_template_arg);
       }
     }
   }
     return true;
 
   default:
     break;
   }

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

 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTFwd.h"
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
                                 lldb::LanguageType language,
                                 ClangASTMetadata *metadata = nullptr,
                                 bool exports_symbols = false);
 
   class TemplateParameterInfos {
   public:
     struct ArgumentMetadata {
       char const *const name = nullptr;
+      bool const is_defaulted = false;
     };
 
     TemplateParameterInfos() = default;
     TemplateParameterInfos(llvm::ArrayRef<ArgumentMetadata> metadata,
                            llvm::ArrayRef<clang::TemplateArgument> args_in)
         : args_metadata(metadata), args(args_in) {
       assert(metadata.size() == args_in.size());
     }
llvm::ArrayRef<ArgumentMetadata> GetMetadata() const {
       return args_metadata;
     }
 
     clang::TemplateArgument const &Front() const {
       assert(!args.empty());
       return args.front();
     }
 
-    void InsertArg(char const *name, clang::TemplateArgument arg) {
+    bool IsDefaultArg(size_t idx) const {
+      assert(args_metadata.size() > idx);
+      return args_metadata[idx].is_defaulted;
+    }
+
+    void InsertArg(char const *name, clang::TemplateArgument arg,
+                   bool is_defaulted = false) {
       args.emplace_back(std::move(arg));
-      args_metadata.push_back({name});
+      args_metadata.push_back({name, is_defaulted});
     }
 
     // Parameter pack related
 
     bool hasParameterPack() const { return static_cast<bool>(packed_args); }
 
     TemplateParameterInfos const &GetParameterPack() const {
       assert(packed_args != nullptr);
private:
     /// Element 'args_metadata[i]' holds the template argument metadata
     /// of 'args[i]'
     llvm::SmallVector<ArgumentMetadata, 2> args_metadata;
     llvm::SmallVector<clang::TemplateArgument, 2> args;
 
     const char * pack_name = nullptr;
     std::unique_ptr<TemplateParameterInfos> packed_args;
   };
 
   clang::FunctionTemplateDecl *CreateFunctionTemplateDecl(
       clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
       clang::FunctionDecl *func_decl, const TemplateParameterInfos &infos);
 
   void CreateFunctionTemplateSpecializationInfo(
       clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template,
       const TemplateParameterInfos &infos);
 
public:
   PDBASTParser *GetPDBParser() override;
   npdb::PdbAstBuilder *GetNativePDBParser() override;
 
   // TypeSystemClang callbacks for external source lookups.
   void CompleteTagDecl(clang::TagDecl *);
 
   void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
 
+  class PrintingCallbacks : public clang::PrintingCallbacks {
+  public:
+    PrintingCallbacks(TypeSystemClang const &ts) : m_ast(ts) {}
+
+    virtual ~PrintingCallbacks() = default;
+
+    TriState
+    IsTemplateArgumentDefaulted(clang::ClassTemplateSpecializationDecl const *D,
+                                size_t ArgIndex) const override {
+      return m_ast.IsTemplateArgumentDefaulted(D, ArgIndex);
+    }
+
+  private:
+    TypeSystemClang const &m_ast;
+  };
+
+  lldb_private::ClangASTImporter *GetClangASTImporter() const;
+
   bool LayoutRecordType(
       const clang::RecordDecl *record_decl, uint64_t &size, uint64_t &alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &base_offsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &vbase_offsets);
 
+  PrintingCallbacks::TriState
+  IsTemplateArgumentDefaulted(clang::ClassTemplateSpecializationDecl const *D,
+                              size_t ArgIndex) const;
+
   /// Creates a CompilerDecl from the given Decl with the current
   /// TypeSystemClang instance as its typesystem.
   /// The Decl has to come from the ASTContext of this
   /// TypeSystemClang.
   CompilerDecl GetCompilerDecl(clang::Decl *decl) {
     assert(&decl->getASTContext() == &getASTContext() &&
            "CreateCompilerDecl for Decl from wrong ASTContext?");
     return CompilerDecl(this, decl);
private:
   /// AccessSpecifier.
   CXXRecordDeclAccessMap m_cxx_record_decl_access;
 
   /// The sema associated that is currently used to build this ASTContext.
   /// May be null if we are already done parsing this ASTContext or the
   /// ASTContext wasn't created by parsing source code.
   clang::Sema *m_sema = nullptr;
 
+  PrintingCallbacks m_printing_callbacks = {*this};
+
   // For TypeSystemClang only
   TypeSystemClang(const TypeSystemClang &);
   const TypeSystemClang &operator=(const TypeSystemClang &);
   /// Creates the internal ASTContext.
   void CreateASTContext();
   void SetTargetTriple(llvm::StringRef target_triple);
 };
 

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

for (size_t i = 0; i < num_template_params; ++i) {
     const char *name = metadata[i].name;
 
     IdentifierInfo *identifier_info = nullptr;
     if (name && name[0])
       identifier_info = &ast.Idents.get(name);
     TemplateArgument const &targ = args[i];
     if (IsValueParam(targ)) {
       QualType template_param_type = targ.getIntegralType();
-      template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
+      auto *decl = NonTypeTemplateParmDecl::Create(
           ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
           identifier_info, template_param_type, parameter_pack,
-          ast.getTrivialTypeSourceInfo(template_param_type)));
+          ast.getTrivialTypeSourceInfo(template_param_type));
+
+      if (template_param_infos.IsDefaultArg(i)) {
+        if (targ.getKind() == TemplateArgument::Integral) {
+          Expr *LiteralExpr = nullptr;
+          if (template_param_type->isBooleanType()) {
+            LiteralExpr = CXXBoolLiteralExpr::Create(
+                ast, !targ.getAsIntegral().isZero(), template_param_type, {});
           } else {
-      template_param_decls.push_back(TemplateTypeParmDecl::Create(
+            LiteralExpr = IntegerLiteral::Create(ast, targ.getAsIntegral(),
+                                                 template_param_type, {});
+          }
+
+          decl->setDefaultArgument(LiteralExpr);
+        }
+      }
+
+      template_param_decls.push_back(decl);
+    } else {
+      auto *decl = TemplateTypeParmDecl::Create(
           ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
-          identifier_info, is_typename, parameter_pack));
+          identifier_info, is_typename, parameter_pack);
+
+      if (template_param_infos.IsDefaultArg(i)) {
+        if (targ.getKind() == TemplateArgument::Type) {
+          decl->setDefaultArgument(
+              ast.getTrivialTypeSourceInfo(targ.getAsType()));
+        } else if (targ.getKind() == TemplateArgument::Template) {
+          decl->setDefaultArgument(ast.getTemplateSpecializationTypeInfo(
+              targ.getAsTemplate(), {}, {}));
+        }
+      }
+
+      template_param_decls.push_back(decl);
     }
   }
 
   if (template_param_infos.hasParameterPack()) {
     IdentifierInfo *identifier_info = nullptr;
     if (template_param_infos.HasPackName())
       identifier_info = &ast.Idents.get(template_param_infos.GetPackName());
     const bool parameter_pack_true = true;
 
ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type,
   // debug info. This also handles when we don't want any scopes preceding the
   // name.
   if (auto *named_decl = qual_type->getAsTagDecl())
     return ConstString(GetTypeNameForDecl(named_decl, !base_only));
 
   return ConstString(qual_type.getAsString(GetTypePrintingPolicy()));
 }
 
+lldb_private::ClangASTImporter *TypeSystemClang::GetClangASTImporter() const {
+  lldb_private::ClangASTImporter *importer = nullptr;
+  if (m_dwarf_ast_parser_up)
+    importer = &m_dwarf_ast_parser_up->GetClangASTImporter();
+  if (!importer && m_pdb_ast_parser_up)
+    importer = &m_pdb_ast_parser_up->GetClangASTImporter();
+  if (!importer && m_native_pdb_ast_parser_up)
+    importer = &m_native_pdb_ast_parser_up->GetClangASTImporter();
+
+  return importer;
+}
+
 ConstString
 TypeSystemClang::GetDisplayTypeName(lldb::opaque_compiler_type_t type) {
   if (!type)
     return ConstString();
 
   clang::QualType qual_type(GetQualType(type));
   clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
   printing_policy.SuppressTagKeyword = true;
   printing_policy.SuppressScope = false;
   printing_policy.SuppressUnwrittenScope = true;
   printing_policy.SuppressInlineNamespace = true;
+  printing_policy.Callbacks = &m_printing_callbacks;
   return ConstString(qual_type.getAsString(printing_policy));
 }
 
 uint32_t
 TypeSystemClang::GetTypeInfo(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_or_element_clang_type) {
   if (!type)
     return 0;

 bool TypeSystemClang::LayoutRecordType(
     const clang::RecordDecl *record_decl, uint64_t &bit_size,
     uint64_t &alignment,
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &base_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &vbase_offsets) {
-  lldb_private::ClangASTImporter *importer = nullptr;
-  if (m_dwarf_ast_parser_up)
-    importer = &m_dwarf_ast_parser_up->GetClangASTImporter();
-  if (!importer && m_pdb_ast_parser_up)
-    importer = &m_pdb_ast_parser_up->GetClangASTImporter();
-  if (!importer && m_native_pdb_ast_parser_up)
-    importer = &m_native_pdb_ast_parser_up->GetClangASTImporter();
+
+  auto *importer = GetClangASTImporter();
   if (!importer)
     return false;
 
   return importer->LayoutRecordType(record_decl, bit_size, alignment,
                                     field_offsets, base_offsets, vbase_offsets);
 }
 
+PrintingCallbacks::TriState TypeSystemClang::IsTemplateArgumentDefaulted(
+    clang::ClassTemplateSpecializationDecl const *D, size_t ArgIndex) const {
+  lldb_private::ClangASTImporter *importer = GetClangASTImporter();
+
+  if (!importer)
+    return PrintingCallbacks::TriState::kUnknown;
+
+  return importer->IsTemplateArgumentDefaulted(D, ArgIndex);
+}
+
 // CompilerDecl override functions
 
 ConstString TypeSystemClang::DeclGetName(void *opaque_decl) {
   if (opaque_decl) {
     clang::NamedDecl *nd =
         llvm::dyn_cast<NamedDecl>((clang::Decl *)opaque_decl);
     if (nd != nullptr)
       return ConstString(nd->getDeclName().getAsString());

lldb/test/API/commands/expression/import-std-module/non-module-type-separation/TestNonModuleTypeSeparation.py

def test(self):
                                           lldb.SBFileSpec("main.cpp"))
 
         children = [
             ValueCheck(value="3"),
             ValueCheck(value="1"),
             ValueCheck(value="2"),
         ]
 
-        # The debug info vector type doesn't know about the default template
-        # arguments, so they will be printed.
-        debug_info_vector_type = "std::vector<int, std::allocator<int> >"
-
-        # The C++ module vector knows its default template arguments and will
-        # suppress them.
-        module_vector_type = "std::vector<int>"
+        vector_type = "std::vector<int>"
 
         # First muddy the scratch AST with non-C++ module types.
-        self.expect_expr("a", result_type=debug_info_vector_type,
+        self.expect_expr("a", result_type=vector_type,
                          result_children=children)
         self.expect_expr("dbg_info_vec",
                          result_type="std::vector<DbgInfoClass, std::allocator<DbgInfoClass> >",
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
-                ValueCheck(name="ints", type=debug_info_vector_type, children=[
+                ValueCheck(name="ints", type=vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])
 
         # Enable the C++ module import and get the module vector type.
         self.runCmd("settings set target.import-std-module true")
-        self.expect_expr("a", result_type=module_vector_type,
+        self.expect_expr("a", result_type=vector_type,
                          result_children=children)
 
         # Test mixed debug info/module types
         self.expect_expr("dbg_info_vec",
                          result_type="std::vector<DbgInfoClass>",
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
-                ValueCheck(name="ints", type=module_vector_type, children=[
+                ValueCheck(name="ints", type=vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])
 
 
         # Turn off the C++ module import and use debug info types again.
         self.runCmd("settings set target.import-std-module false")
-        self.expect_expr("a", result_type=debug_info_vector_type,
+        self.expect_expr("a", result_type=vector_type,
                          result_children=children)
 
         # Test the types that were previoiusly mixed debug info/module types.
         self.expect_expr("dbg_info_vec",
                          result_type="std::vector<DbgInfoClass, std::allocator<DbgInfoClass> >",
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
-                ValueCheck(name="ints", type=debug_info_vector_type, children=[
+                ValueCheck(name="ints", type=vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/TestRetryWithStdModule.py

class TestCase(TestBase):
     def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         # Test printing the vector before enabling any C++ module setting.
-        self.expect_expr("a", result_type="std::vector<int, std::allocator<int> >")
+        self.expect_expr("a", result_type="std::vector<int>")
 
         # Set loading the import-std-module to 'fallback' which loads the module
         # and retries when an expression fails to parse.
         self.runCmd("settings set target.import-std-module fallback")
 
         # Printing the vector still works. This should return the same type
         # as before as this shouldn't use a C++ module type (the C++ module type
         # is hiding the second template parameter as it's equal to the default
         # argument which the C++ module has type info for).
-        self.expect_expr("a", result_type="std::vector<int, std::allocator<int> >")
+        self.expect_expr("a", result_type="std::vector<int>")
 
         # This expression can only parse with a C++ module. LLDB should
         # automatically fall back to import the C++ module to get this working.
         self.expect_expr("std::max<std::size_t>(0U, a.size())", result_value="3")
 
 
         # The 'a' and 'local' part can be parsed without loading a C++ module and will
         # load type/runtime information. The 'std::max...' part will fail to

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/shared_ptr/TestDataFormatterLibcxxSharedPtr.py

def test_shared_ptr_variables(self):
             type="std::shared_ptr<int> &&",
             children=[ValueCheck(name="__ptr_")],
         )
         self.assertRegex(valobj.summary, r"^10( strong=1)? weak=1$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "sp_str",
-            type="std::shared_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >",
+            type="std::shared_ptr<std::basic_string<char> >",
             children=[ValueCheck(name="__ptr_", summary='"hello"')],
         )
         self.assertRegex(valobj.summary, r'^"hello"( strong=1)? weak=1$')
 
         valobj = self.expect_var_path("sp_user", type="std::shared_ptr<User>")
         self.assertRegex(
             valobj.summary,
             "^std(::__[^:]*)?::shared_ptr<User>::element_type @ 0x0*[1-9a-f][0-9a-f]+( strong=1)? weak=1",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

def test_with_run_command(self):
                 '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
                 '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns,
                 '(%s::u16string) u16_string = u"ß水氶"'%ns,
                 # FIXME: This should have a 'u' prefix.
                 '(%s::u16string) u16_empty = ""'%ns,
                 '(%s::u32string) u32_string = U"🍄🍅🍆🍌"'%ns,
                 # FIXME: This should have a 'U' prefix.
                 '(%s::u32string) u32_empty = ""'%ns,
-                '(%s::basic_string<unsigned char, %s::char_traits<unsigned char>, '
-                '%s::allocator<unsigned char> >) uchar = "aaaaa"'%(ns,ns,ns),
+                '(%s::basic_string<unsigned char>) uchar = "aaaaa"'%(ns),
                 '(%s::string *) null_str = nullptr'%ns,
         ])
 
         thread.StepOver()
 
         TheVeryLongOne = frame.FindVariable("TheVeryLongOne")
         summaryOptions = lldb.SBTypeSummaryOptions()
         summaryOptions.SetCapping(lldb.eTypeSummaryUncapped)
def test_with_run_command(self):
                 'L"מזל טוב"',
                 '(%s::string) q = "hello world"'%ns,
                 '(%s::string) Q = "quite a long std::strin with lots of info inside it"'%ns,
                 '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
                 '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns,
                 '(%s::u16string) u16_string = u"ß水氶"'%ns,
                 '(%s::u32string) u32_string = U"🍄🍅🍆🍌"'%ns,
                 '(%s::u32string) u32_empty = ""'%ns,
-                '(%s::basic_string<unsigned char, %s::char_traits<unsigned char>, '
-                '%s::allocator<unsigned char> >) uchar = "aaaaa"'%(ns,ns,ns),
+                '(%s::basic_string<unsigned char>) uchar = "aaaaa"'%(ns),
                 '(%s::string *) null_str = nullptr'%ns,
         ])
 
         # The test assumes that std::string is in its cap-size-data layout.
         is_alternate_layout = ('arm' in self.getArchitecture()) and self.platformIsDarwin()
         if is_64_bit and not is_alternate_layout:
             self.expect("frame variable garbage1", substrs=['garbage1 = Summary Unavailable'])
             self.expect("frame variable garbage2", substrs=[r'garbage2 = "\xfa\xfa\xfa\xfa"'])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string_view/TestDataFormatterLibcxxStringView.py

def test_with_run_command(self):
                              summary='""')
         self.expect_var_path('u32_string',
                              type='std::u32string_view',
                              summary='U"🍄🍅🍆🍌"')
         self.expect_var_path('u32_empty',
                              type='std::u32string_view',
                              summary='""')
         self.expect_var_path('uchar_source',
-                             type='std::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char> >',
+                             type='std::basic_string<unsigned char>',
                              summary='"aaaaaaaaaa"')
         self.expect_var_path('uchar',
-                             type='std::basic_string_view<unsigned char, std::char_traits<unsigned char> >',
+                             type='std::basic_string_view<unsigned char>',
                              summary='"aaaaa"')
         self.expect_var_path('oops',
                              type='std::string_view',
                              summary='"Hellooo World\\n"')
 
         # GetSummary returns None so can't be checked by expect_var_path, so we
         # use the str representation instead
         null_obj = self.frame().GetValueForVariablePath('null_str')
def test_with_run_command(self):
                              summary='""')
         self.expect_var_path('u32_string',
                              type='std::u32string_view',
                              summary='U"🍄🍅🍆🍌"')
         self.expect_var_path('u32_empty',
                              type='std::u32string_view',
                              summary='""')
         self.expect_var_path('uchar_source',
-                             type='std::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char> >',
+                             type='std::basic_string<unsigned char>',
                              summary='"aaaaaaaaaa"')
         self.expect_var_path('uchar',
-                             type='std::basic_string_view<unsigned char, std::char_traits<unsigned char> >',
+                             type='std::basic_string_view<unsigned char>',
                              summary='"aaaaa"')
  
         self.runCmd('cont')
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         broken_obj = self.frame().GetValueForVariablePath('in_str_view')
         self.assertEqual( broken_obj.GetSummary(), "Summary Unavailable" )

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/TestDataFormatterLibcxxUniquePtr.py

def test_unique_ptr_variables(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(
             self, "// break here", lldb.SBFileSpec("main.cpp")
         )
 
         valobj = self.expect_var_path(
             "up_empty",
-            type="std::unique_ptr<int, std::default_delete<int> >",
+            type="std::unique_ptr<int>",
             summary="nullptr",
             children=[ValueCheck(name="__value_")],
         )
         self.assertEqual(
             valobj.child[0].GetValueAsUnsigned(lldb.LLDB_INVALID_ADDRESS), 0
         )
 
         self.expect(
             "frame variable *up_empty", substrs=["(int) *up_empty = <parent is NULL>"]
         )
 
         valobj = self.expect_var_path(
             "up_int",
-            type="std::unique_ptr<int, std::default_delete<int> >",
+            type="std::unique_ptr<int>",
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref",
-            type="std::unique_ptr<int, std::default_delete<int> > &",
+            type="std::unique_ptr<int> &",
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref_ref",
-            type="std::unique_ptr<int, std::default_delete<int> > &&",
+            type="std::unique_ptr<int> &&",
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_str",
-            type="std::unique_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::default_delete<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >",
+            type="std::unique_ptr<std::basic_string<char> >",
             summary='"hello"',
             children=[ValueCheck(name="__value_", summary='"hello"')],
         )
 
         valobj = self.expect_var_path(
-            "up_user", type="std::unique_ptr<User, std::default_delete<User> >"
+            "up_user", type="std::unique_ptr<User>"
         )
         self.assertRegex(valobj.summary, "^User @ 0x0*[1-9a-f][0-9a-f]+$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "*up_user",
             type="User",
             children=[
                 ValueCheck(name="id", value="30"),
                 ValueCheck(name="name", summary='"steph"'),
             ],
         )
         self.assertEqual(str(valobj), '(User) *__value_ = (id = 30, name = "steph")')
 
         self.expect_var_path("up_user->id", type="int", value="30")
         self.expect_var_path("up_user->name", type="std::string", summary='"steph"')

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 //===-- DWARFASTParserClangTests.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
+#include "Plugins/Platform/MacOSX/PlatformRemoteMacOSX.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
+#include "lldb/Core/Debugger.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::dwarf;
 
 namespace {
-class DWARFASTParserClangTests : public testing::Test {};
+static std::once_flag debugger_initialize_flag;
+
+class DWARFASTParserClangTests : public testing::Test {
+  void SetUp() override {
+    HostInfo::Initialize();
+    PlatformMacOSX::Initialize();
+    std::call_once(debugger_initialize_flag,
+                   []() { Debugger::Initialize(nullptr); });
+    ArchSpec arch("x86_64-apple-macosx-");
+    Platform::SetHostPlatform(
+        PlatformRemoteMacOSX::CreateInstance(true, &arch));
+  }
+  void TearDown() override {
+    PlatformMacOSX::Terminate();
+    HostInfo::Terminate();
+  }
+};
 
 class DWARFASTParserClangStub : public DWARFASTParserClang {
 public:
   using DWARFASTParserClang::DWARFASTParserClang;
   using DWARFASTParserClang::LinkDeclContextToDIE;
 
   std::vector<const clang::DeclContext *> GetDeclContextToDIEMapKeys() {
     std::vector<const clang::DeclContext *> keys;
EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max - 1),
                        HasValue(std::to_string(uint_max - 1)));
   EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max),
                        HasValue(std::to_string(uint_max)));
   EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 1),
                        llvm::Failed());
   EXPECT_THAT_EXPECTED(Extract(ast.UnsignedIntTy, uint_max + 2),
                        llvm::Failed());
 }
+
+TEST_F(DWARFASTParserClangTests, TestDefaultTemplateParamParsing) {
+  // Tests parsing DW_AT_default_value for template parameters.
+
+  // template <typename T>
+  // class foo {};
+  //
+  // template <template <typename T> class CT = foo>
+  // class baz {};
+  //
+  // template <typename T = char, int i = 3, bool b = true,
+  //           typename c = foo<T>>
+  // class bar {};
+  //
+  // int main() {
+  //     bar<> br;
+  //     baz<> bz;
+  //     return 0;
+  // }
+  //
+  // YAML generated on Linux using obj2yaml on the above program
+  // compiled with Clang.
+  const char *yamldata = R"(
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_AARCH64
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x4
+    Content:         FF4300D1E0031F2AFF0F00B9FF430091C0035FD6
+  - Name:            .linker-options
+    Type:            SHT_LLVM_LINKER_OPTIONS
+    Flags:           [ SHF_EXCLUDE ]
+    AddressAlign:    0x1
+    Content:         ''
+  - Name:            .debug_abbrev
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         011101252513050325721710171B25111B120673170000022E01111B1206401803253A0B3B0B49133F190000033400021803253A0B3B0B4913000004240003253E0B0B0B0000050201360B03250B0B3A0B3B0B0000062F00491303251E190000073000491303251E191C0D0000083000491303251E191C0F000009020003253C1900000A8682010003251E19904225000000
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         7F00000005000108000000000100210001000000000000000002001400000000000000020014000000016F03000B490000000302910B05000C4D0000000302910A0E000D78000000000404050405050D010009066E000000070749000000080308720000000A0106760000000C000406080104090201090B0505110100050A0F100000
+  - Name:            .debug_str_offsets
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         4C00000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  - Name:            .comment
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x1
+    EntSize:         0x1
+    Content:         00636C616E672076657273696F6E2031362E302E30202868747470733A2F2F6769746875622E636F6D2F6C6C766D2F6C6C766D2D70726F6A65637420343764323862376138323638653337616130646537366238353966343530386533646261633663652900
+  - Name:            .note.GNU-stack
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+  - Name:            .eh_frame
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x8
+    Content:         1000000000000000017A5200017C1E011B0C1F001800000018000000000000001400000000440E104C0E000000000000
+  - Name:            .debug_line
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         580000000500080037000000010101FB0E0D00010101010000000100000101011F010000000003011F020F051E01000000000019537E33C1D1006B79E3D1C33D6EE6A304000009020000000000000000030A0105050ABD0208000101
+  - Name:            .debug_line_str
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x1
+    EntSize:         0x1
+    Content:         2F686F6D652F6761726465690064656661756C74732E63707000
+  - Name:            .rela.debug_info
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .debug_info
+    Relocations:
+      - Offset:          0x8
+        Symbol:          .debug_abbrev
+        Type:            R_AARCH64_ABS32
+      - Offset:          0x11
+        Symbol:          .debug_str_offsets
+        Type:            R_AARCH64_ABS32
+        Addend:          8
+      - Offset:          0x15
+        Symbol:          .debug_line
+        Type:            R_AARCH64_ABS32
+      - Offset:          0x1F
+        Symbol:          .debug_addr
+        Type:            R_AARCH64_ABS32
+        Addend:          8
+  - Name:            .rela.debug_str_offsets
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .debug_str_offsets
+    Relocations:
+      - Offset:          0x8
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+      - Offset:          0xC
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          101
+      - Offset:          0x10
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          114
+      - Offset:          0x14
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          127
+      - Offset:          0x18
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          132
+      - Offset:          0x1C
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          136
+      - Offset:          0x20
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          139
+      - Offset:          0x24
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          144
+      - Offset:          0x28
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          146
+      - Offset:          0x2C
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          148
+      - Offset:          0x30
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          153
+      - Offset:          0x34
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          155
+      - Offset:          0x38
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          165
+      - Offset:          0x3C
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          167
+      - Offset:          0x40
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          198
+      - Offset:          0x44
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          201
+      - Offset:          0x48
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          204
+      - Offset:          0x4C
+        Symbol:          .debug_str
+        Type:            R_AARCH64_ABS32
+        Addend:          208
+  - Name:            .rela.debug_addr
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .debug_addr
+    Relocations:
+      - Offset:          0x8
+        Symbol:          .text
+        Type:            R_AARCH64_ABS64
+  - Name:            .rela.eh_frame
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .eh_frame
+    Relocations:
+      - Offset:          0x1C
+        Symbol:          .text
+        Type:            R_AARCH64_PREL32
+  - Name:            .rela.debug_line
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .debug_line
+    Relocations:
+      - Offset:          0x22
+        Symbol:          .debug_line_str
+        Type:            R_AARCH64_ABS32
+      - Offset:          0x2E
+        Symbol:          .debug_line_str
+        Type:            R_AARCH64_ABS32
+        Addend:          13
+      - Offset:          0x48
+        Symbol:          .text
+        Type:            R_AARCH64_ABS64
+  - Name:            .llvm_addrsig
+    Type:            SHT_LLVM_ADDRSIG
+    Flags:           [ SHF_EXCLUDE ]
+    Link:            .symtab
+    AddressAlign:    0x1
+    Offset:          0x818
+    Symbols:         [  ]
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .linker-options
+      - Name:            .debug_abbrev
+      - Name:            .debug_info
+      - Name:            .rela.debug_info
+      - Name:            .debug_str_offsets
+      - Name:            .rela.debug_str_offsets
+      - Name:            .debug_str
+      - Name:            .debug_addr
+      - Name:            .rela.debug_addr
+      - Name:            .comment
+      - Name:            .note.GNU-stack
+      - Name:            .eh_frame
+      - Name:            .rela.eh_frame
+      - Name:            .debug_line
+      - Name:            .rela.debug_line
+      - Name:            .debug_line_str
+      - Name:            .llvm_addrsig
+      - Name:            .symtab
+Symbols:
+  - Name:            defaults.cpp
+    Type:            STT_FILE
+    Index:           SHN_ABS
+  - Name:            .text
+    Type:            STT_SECTION
+    Section:         .text
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            .debug_abbrev
+    Type:            STT_SECTION
+    Section:         .debug_abbrev
+  - Name:            '$d.1'
+    Section:         .debug_abbrev
+  - Name:            '$d.2'
+    Section:         .debug_info
+  - Name:            .debug_str_offsets
+    Type:            STT_SECTION
+    Section:         .debug_str_offsets
+  - Name:            '$d.3'
+    Section:         .debug_str_offsets
+  - Name:            .debug_str
+    Type:            STT_SECTION
+    Section:         .debug_str
+  - Name:            '$d.4'
+    Section:         .debug_str
+  - Name:            .debug_addr
+    Type:            STT_SECTION
+    Section:         .debug_addr
+  - Name:            '$d.5'
+    Section:         .debug_addr
+  - Name:            '$d.6'
+    Section:         .comment
+  - Name:            '$d.7'
+    Section:         .eh_frame
+  - Name:            .debug_line
+    Type:            STT_SECTION
+    Section:         .debug_line
+  - Name:            '$d.8'
+    Section:         .debug_line
+  - Name:            .debug_line_str
+    Type:            STT_SECTION
+    Section:         .debug_line_str
+  - Name:            '$d.9'
+    Section:         .debug_line_str
+  - Name:            main
+    Type:            STT_FUNC
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x14
+DWARF:
+  debug_str:
+    - 'clang version 16.0.0 (https://github.com/llvm/llvm-project 47d28b7a8268e37aa0de76b859f4508e3dbac6ce)'
+    - defaults.cpp
+    - '/home/gardei'
+    - main
+    - int
+    - br
+    - char
+    - T
+    - i
+    - bool
+    - b
+    - 'foo<char>'
+    - c
+    - 'bar<char, 3, true, foo<char> >'
+    - bz
+    - CT
+    - foo
+    - 'baz<foo>'
+  debug_addr:
+    - Length:          0xC
+      Version:         0x5
+      AddressSize:     0x8
+      Entries:
+        - {}
+...
+)";
+  YAMLModuleTester t(yamldata);
+
+  DWARFUnit *unit = t.GetDwarfUnit();
+  ASSERT_NE(unit, nullptr);
+  const DWARFDebugInfoEntry *cu_entry = unit->DIE().GetDIE();
+  ASSERT_EQ(cu_entry->Tag(), DW_TAG_compile_unit);
+  DWARFDIE cu_die(unit, cu_entry);
+
+  auto holder = std::make_unique<clang_utils::TypeSystemClangHolder>("ast");
+  auto &ast_ctx = *holder->GetAST();
+  DWARFASTParserClangStub ast_parser(ast_ctx);
+
+  llvm::SmallVector<lldb::TypeSP, 2> types;
+  for (DWARFDIE die : cu_die.children()) {
+    if (die.Tag() == DW_TAG_class_type) {
+      SymbolContext sc;
+      bool new_type = false;
+      types.push_back(ast_parser.ParseTypeFromDWARF(sc, die, &new_type));
+    }
+  }
+
+  ASSERT_EQ(types.size(), 3U);
+
+  auto check_decl = [](auto const *decl) {
+    clang::ClassTemplateSpecializationDecl const *ctsd =
+        llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(decl);
+    ASSERT_NE(ctsd, nullptr);
+    clang::ClassTemplateDecl const *ctd = ctsd->getSpecializedTemplate();
+    ASSERT_NE(ctd, nullptr);
+
+    auto const *params = ctd->getTemplateParameters();
+    ASSERT_NE(params, nullptr);
+
+    for (clang::NamedDecl const *param : *params) {
+      ASSERT_NE(param, nullptr);
+      if (auto *decl = llvm::dyn_cast<clang::TemplateTypeParmDecl>(param)) {
+        EXPECT_TRUE(decl->hasDefaultArgument());
+      } else if (auto *decl =
+                     llvm::dyn_cast<clang::NonTypeTemplateParmDecl>(param)) {
+        EXPECT_TRUE(decl->hasDefaultArgument());
+      } else if (auto *decl =
+                     llvm::dyn_cast<clang::TemplateTemplateParmDecl>(param)) {
+        EXPECT_TRUE(decl->hasDefaultArgument());
+      } else {
+        ASSERT_TRUE(false && "Shouldn't ever get here");
+      }
+    }
+  };
+
+  for (auto const &type_sp : types) {
+    ASSERT_NE(type_sp, nullptr);
+    auto const *decl = ClangUtil::GetAsTagDecl(type_sp->GetFullCompilerType());
+    if (decl->getName() == "bar" || decl->getName() == "baz") {
+      check_decl(decl);
+    }
+  }
+}