[lldb] Delete TypeSystemClang::ParseClassTemplateDecl

[teemperor]

Summary

ParseClassTemplateDecl is a leftover from the old days where the TypeSystemClang
predecessor was still doing DWARF parsing. Right now the function just checks that the passed
template args are valid (and returns null if they aren't). It also strips the parameters from the
name<parameter> name (because that's how the DW_AT_name field is filled out by most compilers).

This patch:

1. Inlines ParseClassTemplateDecl logic into the DWARF parser where its only use is.
2. Inside the if (ParseTemplateParameterInfos(...)) scope we know that the template parameters are valid because the function returns args.IsValid(). So we can drop all the unreachable error handling code or replace it with asserts.

There is one non-NFC part in here. ParseTemplateParameterInfos is
supposed to return true if the template args are valid. However the old
implementation just had an outdated copy of the IsValid implementation that
wasn't updated alongside IsValid. This just replaces this with a call to IsValid
which means that some template DIEs that can't be parsed are now handled
by the standard error handling code (aka, turning it into a fake class) and not
the removed log-and-return-null error handling.

The only reason for that change is that we want to know for sure that in
if (ParseTemplateParameterInfos(...)) we have valid template args (and don't
need any other additional error handling).

[labath]

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

1769

name.split('<').first ?

[teemperor]

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

1769

jepp, thanks!

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

if (attrs.accessibility == eAccessNone && decl_ctx) {
       if (DeclKindIsCXXClass(containing_decl_kind))
         attrs.accessibility = default_accessibility;
     }
 
     ClangASTMetadata metadata;
     metadata.SetUserID(die.GetID());
     metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die));
 
-    if (attrs.name.GetStringRef().contains('<')) {
+    const llvm::StringRef name = attrs.name.GetStringRef();
+    if (name.contains('<')) {
       TypeSystemClang::TemplateParameterInfos template_param_infos;
       if (ParseTemplateParameterInfos(die, template_param_infos)) {
+        // name is in the format 'name<parameters>' but the name that
+        // TypeSystemClang wants is just the 'name' prefix, so strip the
+        // '<parameters>' suffix here.
+        const llvm::StringRef template_name = name.substr(0, name.find('<'));
         clang::ClassTemplateDecl *class_template_decl =
-            m_ast.ParseClassTemplateDecl(
-                decl_ctx, GetOwningClangModule(die), attrs.accessibility,
-                attrs.name.GetCString(), tag_decl_kind, template_param_infos);
-        if (!class_template_decl) {
-          if (log) {
-            dwarf->GetObjectFile()->GetModule()->LogMessage(
-                log,
-                "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" "
-                "clang::ClassTemplateDecl failed to return a decl.",
-                static_cast<void *>(this), die.GetOffset(),
-                DW_TAG_value_to_name(tag), attrs.name.GetCString());
-          }
-          return TypeSP();
-        }
+            m_ast.CreateClassTemplateDecl(decl_ctx, GetOwningClangModule(die),
+                                          attrs.accessibility, template_name,
+                                          tag_decl_kind, template_param_infos);
+        assert(class_template_decl &&
+               "CreateClassTemplateDecl unexpectedly failed");
 
         clang::ClassTemplateSpecializationDecl *class_specialization_decl =
             m_ast.CreateClassTemplateSpecializationDecl(
                 decl_ctx, GetOwningClangModule(die), class_template_decl,
                 tag_decl_kind, template_param_infos);
         clang_type = m_ast.CreateClassTemplateSpecializationType(
             class_specialization_decl);
         clang_type_was_created = true;
for (DWARFDIE die : parent_die.children()) {
     case DW_TAG_GNU_template_template_param:
       ParseTemplateDIE(die, template_param_infos);
       break;
 
     default:
       break;
     }
   }
-  return template_param_infos.args.size() == template_param_infos.names.size();
+  return template_param_infos.IsValid();
 }
 
 bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
                                              lldb_private::Type *type,
                                              CompilerType &clang_type) {
   const dw_tag_t tag = die.Tag();
   SymbolFileDWARF *dwarf = die.GetDWARF();
 

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

#endif
   static clang::TypedefNameDecl *GetAsTypedefDecl(const CompilerType &type);
 
   static clang::CXXRecordDecl *
   GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type);
 
   static clang::ObjCInterfaceDecl *
   GetAsObjCInterfaceDecl(const CompilerType &type);
 
-  clang::ClassTemplateDecl *ParseClassTemplateDecl(
-      clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
-      lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
-      const TypeSystemClang::TemplateParameterInfos &template_param_infos);
-
   clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx,
                                            OptionalClangModuleID owning_module);
 
   clang::UsingDirectiveDecl *
   CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx,
                                   OptionalClangModuleID owning_module,
                                   clang::NamespaceDecl *ns_decl);
 

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

static bool ClassTemplateAllowsToInstantiationArgs(
 
   return class_template_decl;
 }
 
 ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
     DeclContext *decl_ctx, OptionalClangModuleID owning_module,
     lldb::AccessType access_type, llvm::StringRef class_name, int kind,
     const TemplateParameterInfos &template_param_infos) {
+  assert(template_param_infos.IsValid() &&
+         "Passed invalid template parameters?");
+
   ASTContext &ast = getASTContext();
 
   ClassTemplateDecl *class_template_decl = nullptr;
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
 
   IdentifierInfo &identifier_info = ast.Idents.get(class_name);
   DeclarationName decl_name(&identifier_info);
if (ClangUtil::IsClangType(type)) {
 
     default:
       printf("TypeSystemClang::DumpTypeName() type_class = %u", type_class);
       break;
     }
   }
 }
 
-clang::ClassTemplateDecl *TypeSystemClang::ParseClassTemplateDecl(
-    clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
-    lldb::AccessType access_type, const char *parent_name, int tag_decl_kind,
-    const TypeSystemClang::TemplateParameterInfos &template_param_infos) {
-  if (template_param_infos.IsValid()) {
-    std::string template_basename(parent_name);
-    template_basename.erase(template_basename.find('<'));
-
-    return CreateClassTemplateDecl(decl_ctx, owning_module, access_type,
-                                   template_basename.c_str(), tag_decl_kind,
-                                   template_param_infos);
-  }
-  return nullptr;
-}
-
 void TypeSystemClang::CompleteTagDecl(clang::TagDecl *decl) {
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }