[lldb] Make TypeSystemClang work with redeclarations

This patch is a part of D101950 which makes LLDB use redeclarations in its internal clang ASTs.

This patch does the following:

Add an API that allows redeclaring a declaration inside a TypeSystemClang.
Make the TypeSystemClang APIs work with redeclarations. Mainly making sure we look at redeclarations of DeclContext (see the added calls to getPrimaryContext which for example finds the definition of a class. See also the test for nested types)
Removes code that assumes a 1-1 mapping between Type and Decl (which is no longer true for redeclarations). The biggest offender here are the APIs for creating classes/templates/etc. as they return all CompilerType (which doesn't identify a unique Decl, but only a redeclaration chain).
Removed code that tries to eagerly create types for declarations. Types should be created via GetTypeForDecl so that existing types from forward declarations are reused. Otherwise we end up with
The patch also makes that we store the TemplateParameterInfos for template specializations
in the TypeSystemClang. The only reason for this is that Clang is using a different data
structure for storing this info internally so we can't just reuse the information from the
forward declaration when creating the redeclaration (see CreateRedeclaration). This
can be removed once we updated the DWARF parser and the TypeSystemClang APIs
to accept the information as we can find it in the Clang AST.

This shouldn't affect LLDB's functionality on its own as the DWARF parser currently doesn't
create redeclarations. That's why all the tests are unit tests.

The added logic for looking for the right redeclaration should work as before in ASTs that only
have single-decl redeclaration chains (which is what we currently do).

Author: Michael137

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

@@ -295,6 +295,7 @@ class CompleteTagDeclsScope : public ClangASTImporter::NewDeclListener {
     // Filter out decls that we can't complete later.
     if (!isa<TagDecl>(to) && !isa<ObjCInterfaceDecl>(to))
       return;
+
     RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from);
     // We don't need to complete injected class name decls.
     if (from_record_decl && from_record_decl->isInjectedClassName())
@@ -757,6 +758,9 @@ bool ClangASTImporter::LayoutRecordType(
         &base_offsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &vbase_offsets) {
+
+  record_decl = llvm::cast<RecordDecl>(record_decl->getFirstDecl());
+
   RecordDeclToLayoutMap::iterator pos =
       m_record_decl_to_layout_map.find(record_decl);
   base_offsets.clear();
@@ -788,6 +792,7 @@ bool ClangASTImporter::LayoutRecordType(
 
 void ClangASTImporter::SetRecordLayout(clang::RecordDecl *decl,
                                         const LayoutInfo &layout) {
+  decl = llvm::cast<RecordDecl>(decl->getFirstDecl());
   assert(!HasRecordLayout(decl) && "Trying to overwrite layout?");
   m_record_decl_to_layout_map.insert(std::make_pair(decl, layout));
 }
@@ -819,7 +824,10 @@ bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) {
 
 bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl,
                                                  clang::TagDecl *origin_decl) {
-  SetDeclOrigin(decl, origin_decl);
+  if (!origin_decl->getDefinition())
+    return false;
+
+  SetDeclOrigin(decl, origin_decl->getFirstDecl());
   return CompleteTagDecl(decl);
 }
 

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

@@ -175,6 +175,8 @@ class ClangASTImporter {
 
   bool CompleteTagDecl(clang::TagDecl *decl);
 
+  /// This function assumes origin has been completed (i.e., has a valid
+  /// definition).
   bool CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin);
 
   bool CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *interface_decl);

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

@@ -281,8 +281,11 @@ void ClangASTSource::CompleteType(TagDecl *tag_decl) {
   if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
     // We couldn't complete the type.  Maybe there's a definition somewhere
     // else that can be completed.
-    if (TagDecl *alternate = FindCompleteType(tag_decl))
+    if (TagDecl *alternate = FindCompleteType(tag_decl)) {
+      assert(alternate->getDefinition() != nullptr &&
+             "Trying to complete a TagDecl from an incomplete origin");
       m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate);
+    }
   }
 
   LLDB_LOG(log, "      [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl));

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

@@ -10,6 +10,7 @@
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "clang/AST/DeclObjC.h"
 
 using namespace clang;
 using namespace lldb_private;
@@ -65,6 +66,16 @@ clang::TagDecl *ClangUtil::GetAsTagDecl(const CompilerType &type) {
   return qual_type->getAsTagDecl();
 }
 
+clang::Decl *ClangUtil::GetFirstDecl(clang::Decl *d) {
+  if (!d)
+    return nullptr;
+  if (auto *td = llvm::dyn_cast<clang::TagDecl>(d))
+    return td->getFirstDecl();
+  if (auto *od = llvm::dyn_cast<clang::ObjCInterfaceDecl>(d))
+    return od->getFirstDecl();
+  return d;
+}
+
 std::string ClangUtil::DumpDecl(const clang::Decl *d) {
   if (!d)
     return "nullptr";

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

@@ -36,6 +36,15 @@ struct ClangUtil {
 
   static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
 
+  /// If the given Decl is redeclarable, return the first declaration in its
+  /// redeclaration chain. Otherwise return d itself.
+  static clang::Decl *GetFirstDecl(clang::Decl *d);
+
+  /// \see ClangUtil::GetFirstDecl
+  static const clang::Decl *GetFirstDecl(const clang::Decl *d) {
+    return GetFirstDecl(const_cast<clang::Decl *>(d));
+  }
+
   /// Returns a textual representation of the given Decl's AST. Does not
   /// deserialize any child nodes.
   static std::string DumpDecl(const clang::Decl *d);