[lldb] Make TypeSystemClang work with redeclarations

[teemperor]

Summary

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

This patch does the following:

1. Add an API that allows redeclaring a declaration inside a TypeSystemClang.
2. 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)
3. 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).
4. 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).

[teemperor]

Note that the changed Dump method and the dump method that takes an ExecutionContext are not tested as we can't test those things via unit tests. They can only be tested with an updated DWARF parser on a real executable/process.

[teemperor]

• Clang-format some last minute renames

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

struct ClangUtil {
   static clang::QualType GetQualType(const CompilerType &ct);
 
   static clang::QualType GetCanonicalQualType(const CompilerType &ct);
 
   static CompilerType RemoveFastQualifiers(const CompilerType &ct);
 
   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);
   /// Returns a textual representation of the given type.
   static std::string ToString(const clang::Type *t);
   /// Returns a textual representation of the given CompilerType (assuming
   /// its underlying type is a Clang type).
   static std::string ToString(const CompilerType &c);
 };
 }
 
 #endif

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

 //===-- ClangUtil.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
 //
 // A collection of helper methods and data structures for manipulating clang
 // types and decls.
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "clang/AST/DeclObjC.h"
 
 using namespace clang;
 using namespace lldb_private;
 
 bool ClangUtil::IsClangType(const CompilerType &ct) {
   // Invalid types are never Clang types.
   if (!ct)
     return false;

 clang::TagDecl *ClangUtil::GetAsTagDecl(const CompilerType &type) {
   clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
   if (qual_type.isNull())
     return nullptr;
 
   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";
 
   std::string result;
   llvm::raw_string_ostream stream(result);
   bool deserialize = false;
   d->dump(stream, deserialize);

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

assert(qt->getAsTagDecl() == nullptr ||
            &qt->getAsTagDecl()->getASTContext() == &getASTContext());
     return CompilerType(this, qt.getAsOpaquePtr());
   }
 
   CompilerType GetTypeForDecl(clang::NamedDecl *decl);
 
   CompilerType GetTypeForDecl(clang::TagDecl *decl);
 
-  CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
+  CompilerType GetTypeForDecl(const clang::ObjCInterfaceDecl *objc_decl);
 
   template <typename RecordDeclType>
   CompilerType
   GetTypeForIdentifier(ConstString type_name,
                        clang::DeclContext *decl_context = nullptr) {
     CompilerType compiler_type;
 
     if (type_name.GetLength()) {
OptionalClangModuleID GetOrCreateClangModule(llvm::StringRef name,
                                                bool is_explicit = false);
 
   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
                                 OptionalClangModuleID owning_module,
                                 lldb::AccessType access_type,
                                 llvm::StringRef name, int kind,
                                 lldb::LanguageType language,
                                 ClangASTMetadata *metadata = nullptr,
+                                bool exports_symbols = false) {
+    clang::NamedDecl *d =
+        CreateRecordDecl(decl_ctx, owning_module, access_type, name, kind,
+                         language, metadata, exports_symbols);
+    return GetTypeForDecl(d);
+  }
+
+  clang::NamedDecl *CreateRecordDecl(clang::DeclContext *decl_ctx,
+                                     OptionalClangModuleID owning_module,
+                                     lldb::AccessType access_type,
+                                     llvm::StringRef name, int kind,
+                                     lldb::LanguageType language,
+                                     ClangASTMetadata *metadata = nullptr,
                                      bool exports_symbols = false);
 
   class TemplateParameterInfos {
   public:
+    TemplateParameterInfos() = default;
+    TemplateParameterInfos(const TemplateParameterInfos &o) { *this = o; }
+    TemplateParameterInfos &operator=(const TemplateParameterInfos &o) {
+      names = o.names;
+      args = o.args;
+      pack_name = o.pack_name;
+      if (o.packed_args)
+        packed_args = std::make_unique<TemplateParameterInfos>(*o.packed_args);
+      return *this;
+    }
+
     bool IsValid() const {
       // Having a pack name but no packed args doesn't make sense, so mark
       // these template parameters as invalid.
       if (pack_name && !packed_args)
         return false;
       return args.size() == names.size() &&
         (!packed_args || !packed_args->packed_args);
     }
 
     bool hasParameterPack() const { return static_cast<bool>(packed_args); }
 
     llvm::SmallVector<const char *, 2> names;
     llvm::SmallVector<clang::TemplateArgument, 2> args;
-    
-    const char * pack_name = nullptr;
+    llvm::Optional<std::string> pack_name;
     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(
public:
   bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size);
 
   static bool RecordHasFields(const clang::RecordDecl *record_decl);
 
   CompilerType CreateObjCClass(llvm::StringRef name,
                                clang::DeclContext *decl_ctx,
                                OptionalClangModuleID owning_module,
                                bool isForwardDecl, bool isInternal,
-                               ClangASTMetadata *metadata = nullptr);
+                               ClangASTMetadata *metadata = nullptr) {
+    clang::ObjCInterfaceDecl *d = CreateObjCDecl(
+        name, decl_ctx, owning_module, isForwardDecl, isInternal, metadata);
+    return GetTypeForDecl(d);
+  }
+
+  clang::ObjCInterfaceDecl *
+  CreateObjCDecl(llvm::StringRef name, clang::DeclContext *decl_ctx,
+                 OptionalClangModuleID owning_module, bool isForwardDecl,
+                 bool isInternal, ClangASTMetadata *metadata = nullptr);
 
   // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
   // enumerations
 
   // Namespace Declarations
 
   clang::NamespaceDecl *
   GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
public:
   CompilerType CreateBlockPointerType(const CompilerType &function_type);
 
   // Array Types
 
   CompilerType CreateArrayType(const CompilerType &element_type,
                                size_t element_count, bool is_vector);
 
   // Enumeration Types
-  CompilerType CreateEnumerationType(llvm::StringRef name,
+  clang::EnumDecl *CreateEnumerationDecl(llvm::StringRef name,
                                          clang::DeclContext *decl_ctx,
                                          OptionalClangModuleID owning_module,
                                          const Declaration &decl,
                                          const CompilerType &integer_qual_type,
                                          bool is_scoped);
 
+  CompilerType CreateEnumerationType(llvm::StringRef name,
+                                     clang::DeclContext *decl_ctx,
+                                     OptionalClangModuleID owning_module,
+                                     const Declaration &decl,
+                                     const CompilerType &integer_qual_type,
+                                     bool is_scoped) {
+    clang::EnumDecl *enum_decl = CreateEnumerationDecl(
+        name, decl_ctx, owning_module, decl, integer_qual_type, is_scoped);
+    return GetType(getASTContext().getTagDeclType(enum_decl));
+  }
+
   // Integer type functions
 
   CompilerType GetIntTypeFromBitSize(size_t bit_size, bool is_signed);
 
   CompilerType GetPointerSizedIntType(bool is_signed);
 
   // Floating point functions
 
   static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
                                               size_t bit_size);
 
   // TypeSystem methods
   DWARFASTParser *GetDWARFParser() override;
   PDBASTParser *GetPDBParser() override;
 
   // TypeSystemClang callbacks for external source lookups.
   void CompleteTagDecl(clang::TagDecl *);
 
   void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
 
+  /// Creates a redeclaration for the declaration specified by the given type.
+  /// The redeclaration will be at the end of the redeclaration chain. The
+  /// passed declaration has to be created via a TypeSystemClang interface.
+  ///
+  /// \param type The type which declaration should be redeclared. Has to be
+  /// an Objective-C interface type (or Objective-C type), RecordType or
+  /// EnumType.
+  void CreateRedeclaration(CompilerType ct);
+
   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);
 
private:
   typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
   /// Maps Decls to their associated ClangASTMetadata.
   DeclMetadataMap m_decl_metadata;
 
   typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
   /// Maps Types to their associated ClangASTMetadata.
   TypeMetadataMap m_type_metadata;
 
+  /// The information we need to redeclare a class template but that we can't
+  /// gather from the forward declaration.
+  struct ClassTemplateRedeclInfo {
+    TemplateParameterInfos m_template_args;
+  };
+  typedef llvm::DenseMap<const clang::Decl *, ClassTemplateRedeclInfo>
+      ClassTemplateRedeclInfoMap;
+  // FIXME: This is in theory redundant. Instead we should change the way we
+  // create ClassTemplateSpecializationDecls in TypeSystemClang so that we can
+  // just pass the data from the forward declaration.
+  ClassTemplateRedeclInfoMap m_class_template_redecl_infos;
+
   /// 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;
 
   // For TypeSystemClang only
   TypeSystemClang(const TypeSystemClang &);
   const TypeSystemClang &operator=(const TypeSystemClang &);

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

if (clang::ObjCInterfaceDecl *interface_decl =
       llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
     return GetTypeForDecl(interface_decl);
   if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
     return GetTypeForDecl(tag_decl);
   return CompilerType();
 }
 
 CompilerType TypeSystemClang::GetTypeForDecl(TagDecl *decl) {
-  return GetType(getASTContext().getTagDeclType(decl));
+  // Create the type for the TagDecl. Pass the previous decl to make sure that
+  // all redeclarations share the same type.
+  return GetType(
+      getASTContext().getTypeDeclType(decl, decl->getPreviousDecl()));
 }
 
-CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
-  return GetType(getASTContext().getObjCInterfaceType(decl));
+CompilerType TypeSystemClang::GetTypeForDecl(const ObjCInterfaceDecl *decl) {
+  // FIXME: getObjCInterfaceType second parameter could be const.
+  // Create the type for the ObjCInterfaceDecl. Pass the previous decl to make
+  // sure that all redeclarations share the same type.
+  return GetType(getASTContext().getObjCInterfaceType(
+      decl, const_cast<ObjCInterfaceDecl *>(decl->getPreviousDecl())));
 }
 
 #pragma mark Structure, Unions, Classes
 
 void TypeSystemClang::SetOwningModule(clang::Decl *decl,
                                       OptionalClangModuleID owning_module) {
   if (!decl || !owning_module.HasValue())
     return;
std::tie(module, created) = m_module_map_up->findOrCreateModule(
       name, parent_desc ? parent_desc->getModuleOrNull() : nullptr,
       is_framework, is_explicit);
   if (!created)
     return ast_source->GetIDForModule(module);
 
   return ast_source->RegisterModule(module);
 }
 
-CompilerType TypeSystemClang::CreateRecordType(
+clang::NamedDecl *TypeSystemClang::CreateRecordDecl(
     clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
     AccessType access_type, llvm::StringRef name, int kind,
     LanguageType language, ClangASTMetadata *metadata, bool exports_symbols) {
   ASTContext &ast = getASTContext();
 
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
+  decl_ctx = decl_ctx->getPrimaryContext();
 
   if (language == eLanguageTypeObjC ||
       language == eLanguageTypeObjC_plus_plus) {
     bool isForwardDecl = true;
     bool isInternal = false;
-    return CreateObjCClass(name, decl_ctx, owning_module, isForwardDecl,
-                           isInternal, metadata);
+    return CreateObjCDecl(name, decl_ctx, owning_module, isForwardDecl,
   }
 
   // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
   // we will need to update this code. I was told to currently always use the
   // CXXRecordDecl class since we often don't know from debug information if
   // something is struct or a class, so we default to always use the more
   // complete definition just in case.
 
if (metadata)
     SetMetadata(decl, *metadata);
 
   if (access_type != eAccessNone)
     decl->setAccess(ConvertAccessTypeToAccessSpecifier(access_type));
 
   if (decl_ctx)
     decl_ctx->addDecl(decl);
 
-  return GetType(ast.getTagDeclType(decl));
+  return decl;
 }
 
 namespace {
 /// Returns true iff the given TemplateArgument should be represented as an
 /// NonTypeTemplateParmDecl in the AST.
 bool IsValueParam(const clang::TemplateArgument &argument) {
   return argument.getKind() == TemplateArgument::Integral;
 }
if (IsValueParam(template_param_infos.args[i])) {
       template_param_decls.push_back(TemplateTypeParmDecl::Create(
           ast, decl_context, SourceLocation(), SourceLocation(), depth, i,
           identifier_info, is_typename, parameter_pack));
     }
   }
 
   if (template_param_infos.packed_args) {
     IdentifierInfo *identifier_info = nullptr;
-    if (template_param_infos.pack_name && template_param_infos.pack_name[0])
-      identifier_info = &ast.Idents.get(template_param_infos.pack_name);
+    if (template_param_infos.pack_name &&
+        !template_param_infos.pack_name->empty())
+      identifier_info =
+          &ast.Idents.get(template_param_infos.pack_name->c_str());
     const bool parameter_pack_true = true;
 
     if (!template_param_infos.packed_args->args.empty() &&
         IsValueParam(template_param_infos.packed_args->args[0])) {
       QualType template_param_type =
           template_param_infos.packed_args->args[0].getIntegralType();
       template_param_decls.push_back(NonTypeTemplateParmDecl::Create(
           ast, decl_context, SourceLocation(), SourceLocation(), depth,
ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
     DeclContext *decl_ctx, OptionalClangModuleID owning_module,
     lldb::AccessType access_type, llvm::StringRef class_name, int kind,
     const TemplateParameterInfos &template_param_infos) {
   ASTContext &ast = getASTContext();
 
   ClassTemplateDecl *class_template_decl = nullptr;
   if (decl_ctx == nullptr)
     decl_ctx = ast.getTranslationUnitDecl();
+  decl_ctx = decl_ctx->getPrimaryContext();
 
   IdentifierInfo &identifier_info = ast.Idents.get(class_name);
   DeclarationName decl_name(&identifier_info);
 
   // Search the AST for an existing ClassTemplateDecl that could be reused.
   clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
   for (NamedDecl *decl : result) {
     class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
return TemplateTemplateParmDecl::Create(
       /*IsParameterPack*/ false, &identifier_info, template_param_list);
 }
 
 ClassTemplateSpecializationDecl *
 TypeSystemClang::CreateClassTemplateSpecializationDecl(
     DeclContext *decl_ctx, OptionalClangModuleID owning_module,
     ClassTemplateDecl *class_template_decl, int kind,
     const TemplateParameterInfos &template_param_infos) {
+  decl_ctx = decl_ctx->getPrimaryContext();
+
   ASTContext &ast = getASTContext();
   llvm::SmallVector<clang::TemplateArgument, 2> args(
       template_param_infos.args.size() +
       (template_param_infos.packed_args ? 1 : 0));
   std::copy(template_param_infos.args.begin(), template_param_infos.args.end(),
             args.begin());
   if (template_param_infos.packed_args) {
     args[args.size() - 1] = TemplateArgument::CreatePackCopy(
         ast, template_param_infos.packed_args->args);
   }
   ClassTemplateSpecializationDecl *class_template_specialization_decl =
       ClassTemplateSpecializationDecl::CreateDeserialized(ast, 0);
   class_template_specialization_decl->setTagKind(
       static_cast<TagDecl::TagKind>(kind));
   class_template_specialization_decl->setDeclContext(decl_ctx);
   class_template_specialization_decl->setInstantiationOf(class_template_decl);
   class_template_specialization_decl->setTemplateArgs(
       TemplateArgumentList::CreateCopy(ast, args));
-  ast.getTypeDeclType(class_template_specialization_decl, nullptr);
   class_template_specialization_decl->setDeclName(
       class_template_decl->getDeclName());
   SetOwningModule(class_template_specialization_decl, owning_module);
   decl_ctx->addDecl(class_template_specialization_decl);
 
   class_template_specialization_decl->setSpecializationKind(
       TSK_ExplicitSpecialization);
 
+  // Store the information that is needed to later redeclare this exact
+  // template specialization.
+  ClassTemplateRedeclInfo redecl_info;
+  redecl_info.m_template_args = template_param_infos;
+  m_class_template_redecl_infos[class_template_specialization_decl] =
+      redecl_info;
+
   return class_template_specialization_decl;
 }
 
 CompilerType TypeSystemClang::CreateClassTemplateSpecializationType(
     ClassTemplateSpecializationDecl *class_template_specialization_decl) {
   if (class_template_specialization_decl) {
     ASTContext &ast = getASTContext();
     return GetType(ast.getTagDeclType(class_template_specialization_decl));
for (base_class = cxx_record_decl->bases_begin(),
         return true;
     }
   }
   return false;
 }
 
 #pragma mark Objective-C Classes
 
-CompilerType TypeSystemClang::CreateObjCClass(
+clang::ObjCInterfaceDecl *TypeSystemClang::CreateObjCDecl(
     llvm::StringRef name, clang::DeclContext *decl_ctx,
     OptionalClangModuleID owning_module, bool isForwardDecl, bool isInternal,
     ClangASTMetadata *metadata) {
   ASTContext &ast = getASTContext();
   assert(!name.empty());
   if (!decl_ctx)
     decl_ctx = ast.getTranslationUnitDecl();
 
   ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0);
   decl->setDeclContext(decl_ctx);
   decl->setDeclName(&ast.Idents.get(name));
   /*isForwardDecl,*/
   decl->setImplicit(isInternal);
   SetOwningModule(decl, owning_module);
 
   if (metadata)
     SetMetadata(decl, *metadata);
 
-  return GetType(ast.getObjCInterfaceType(decl));
+  return decl;
 }
 
 static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
   return !TypeSystemClang::RecordHasFields(b->getType()->getAsCXXRecordDecl());
 }
 
 uint32_t
 TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
CompilerType TypeSystemClang::GetOrCreateStructForIdentifier(
   if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
     return type;
 
   return CreateStructForIdentifier(type_name, type_fields, packed);
 }
 
 #pragma mark Enumeration Types
 
-CompilerType TypeSystemClang::CreateEnumerationType(
+clang::EnumDecl *TypeSystemClang::CreateEnumerationDecl(
     llvm::StringRef name, clang::DeclContext *decl_ctx,
     OptionalClangModuleID owning_module, const Declaration &decl,
     const CompilerType &integer_clang_type, bool is_scoped) {
   // TODO: Do something intelligent with the Declaration object passed in
   // like maybe filling in the SourceLocation with it...
   ASTContext &ast = getASTContext();
 
   // TODO: ask about these...
clang::EnumDecl *TypeSystemClang::CreateEnumerationDecl(
   if (decl_ctx)
     decl_ctx->addDecl(enum_decl);
 
   // TODO: check if we should be setting the promotion type too?
   enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
 
   enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
 
-  return GetType(ast.getTagDeclType(enum_decl));
+  return enum_decl;
 }
 
 CompilerType TypeSystemClang::GetIntTypeFromBitSize(size_t bit_size,
                                                     bool is_signed) {
   clang::ASTContext &ast = getASTContext();
 
   if (is_signed) {
     if (bit_size == ast.getTypeSize(ast.SignedCharTy))
if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
     if (objc_interface_decl->getDefinition())
       return true;
 
     if (!objc_interface_decl->hasExternalLexicalStorage())
       return false;
 
     ast_source->CompleteType(objc_interface_decl);
 
-    return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
+    objc_interface_decl = objc_interface_decl->getDefinition();
+
+    return objc_interface_decl &&
+           !objc_interface_decl->getTypeForDecl()->isIncompleteType();
   } else {
     return false;
   }
 }
 
 void TypeSystemClang::SetMetadataAsUserID(const clang::Decl *decl,
                                           user_id_t user_id) {
   ClangASTMetadata meta_data;
   meta_data.SetUserID(user_id);
   SetMetadata(decl, meta_data);
 }
 
 void TypeSystemClang::SetMetadataAsUserID(const clang::Type *type,
                                           user_id_t user_id) {
   ClangASTMetadata meta_data;
   meta_data.SetUserID(user_id);
   SetMetadata(type, meta_data);
 }
 
+/// Returns the Decl in a redeclaration chain that is used to store the
+/// the ClangASTMetadata in the metadata map.
+static const clang::Decl *GetDeclForMetadataStorage(const clang::Decl *d) {
+  // Only the first Decl never changes and never requires any loading from
+  // the ExternalASTSource, so it can be a stable key for the map.
+  return ClangUtil::GetFirstDecl(d);
+}
+
 void TypeSystemClang::SetMetadata(const clang::Decl *object,
                                   ClangASTMetadata &metadata) {
-  m_decl_metadata[object] = metadata;
+  m_decl_metadata[GetDeclForMetadataStorage(object)] = metadata;
 }
 
 void TypeSystemClang::SetMetadata(const clang::Type *object,
                                   ClangASTMetadata &metadata) {
   m_type_metadata[object] = metadata;
 }
 
 ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Decl *object) {
-  auto It = m_decl_metadata.find(object);
+  auto It = m_decl_metadata.find(GetDeclForMetadataStorage(object));
   if (It != m_decl_metadata.end())
     return &It->second;
   return nullptr;
 }
 
 ClangASTMetadata *TypeSystemClang::GetMetadata(const clang::Type *object) {
   auto It = m_type_metadata.find(object);
   if (It != m_type_metadata.end())
CompilerType TypeSystemClang::CreateTypedef(
   if (type && typedef_name && typedef_name[0]) {
     clang::ASTContext &clang_ast = getASTContext();
     clang::QualType qual_type(GetQualType(type));
 
     clang::DeclContext *decl_ctx =
         TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (!decl_ctx)
       decl_ctx = getASTContext().getTranslationUnitDecl();
+    decl_ctx = decl_ctx->getPrimaryContext();
 
     clang::TypedefDecl *decl =
         clang::TypedefDecl::CreateDeserialized(clang_ast, 0);
     decl->setDeclContext(decl_ctx);
     decl->setDeclName(&clang_ast.Idents.get(typedef_name));
     decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type));
     decl_ctx->addDecl(decl);
     SetOwningModule(decl, TypePayloadClang(payload).GetOwningModule());
void TypeSystemClang::ForEachEnumerator(
     std::function<bool(const CompilerType &integer_type,
                        ConstString name,
                        const llvm::APSInt &value)> const &callback) {
   const clang::EnumType *enum_type =
       llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
   if (enum_type) {
     const clang::EnumDecl *enum_decl = enum_type->getDecl();
     if (enum_decl) {
+      enum_decl = enum_decl->getDefinition();
+      if (!enum_decl)
+        return;
       CompilerType integer_type = GetType(enum_decl->getIntegerType());
 
       clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
       for (enum_pos = enum_decl->enumerator_begin(),
           enum_end_pos = enum_decl->enumerator_end();
            enum_pos != enum_end_pos; ++enum_pos) {
         ConstString name(enum_pos->getNameAsString().c_str());
         if (!callback(integer_type, name, enum_pos->getInitVal()))
clang::CXXMethodDecl *TypeSystemClang::AddMethodToCXXRecordType(
     bool is_explicit, bool is_attr_used, bool is_artificial) {
   if (!type || !method_clang_type.IsValid() || name.empty())
     return nullptr;
 
   clang::QualType record_qual_type(GetCanonicalQualType(type));
 
   clang::CXXRecordDecl *cxx_record_decl =
       record_qual_type->getAsCXXRecordDecl();
+  if (cxx_record_decl)
+    cxx_record_decl = cxx_record_decl->getDefinition();
 
   if (cxx_record_decl == nullptr)
     return nullptr;
 
   clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
 
   clang::CXXMethodDecl *cxx_method_decl = nullptr;
 
clang::ObjCMethodDecl *TypeSystemClang::AddMethodToObjCObjectType(
 
   if (num_args != num_selectors_with_args)
     return nullptr; // some debug information is corrupt.  We are not going to
                     // deal with it.
 
   auto *objc_method_decl = clang::ObjCMethodDecl::CreateDeserialized(ast, 0);
   objc_method_decl->setDeclName(method_selector);
   objc_method_decl->setReturnType(method_function_prototype->getReturnType());
-  objc_method_decl->setDeclContext(
-      lldb_ast->GetDeclContextForType(ClangUtil::GetQualType(type)));
+  objc_method_decl->setDeclContext(class_interface_decl);
   objc_method_decl->setInstanceMethod(isInstance);
   objc_method_decl->setVariadic(isVariadic);
   objc_method_decl->setPropertyAccessor(isPropertyAccessor);
   objc_method_decl->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
   objc_method_decl->setImplicit(isImplicitlyDeclared);
   objc_method_decl->setDefined(isDefined);
   objc_method_decl->setDeclImplementation(impControl);
   objc_method_decl->setRelatedResultType(HasRelatedResultType);

 
 bool TypeSystemClang::StartTagDeclarationDefinition(const CompilerType &type) {
   clang::QualType qual_type(ClangUtil::GetQualType(type));
   if (!qual_type.isNull()) {
     const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
     if (tag_type) {
       clang::TagDecl *tag_decl = tag_type->getDecl();
       if (tag_decl) {
-        tag_decl->startDefinition();
+        // There are several declarations in the redeclaration chain that could
+        // define this type. The most logical declaration that we could turn
+        // into a definition is the most recent one.
+        clang::TagDecl *def = tag_decl->getMostRecentDecl();
+        def->startDefinition();
         return true;
       }
     }
 
     const clang::ObjCObjectType *object_type =
         qual_type->getAs<clang::ObjCObjectType>();
     if (object_type) {
       clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
       if (interface_decl) {
-        interface_decl->startDefinition();
+        // There are several declarations in the redeclaration chain that could
+        // define this type. The most logical declaration that we could turn
+        // into a definition is the most recent one.
+        clang::ObjCInterfaceDecl *def = interface_decl->getMostRecentDecl();
+        def->startDefinition();
         return true;
       }
     }
   }
   return false;
 }
 
 bool TypeSystemClang::CompleteTagDeclarationDefinition(
case clang::Type::Record:
     }
     return;
 
   case clang::Type::Enum:
     if (GetCompleteType(type)) {
       const clang::EnumType *enutype =
           llvm::cast<clang::EnumType>(qual_type.getTypePtr());
       const clang::EnumDecl *enum_decl = enutype->getDecl();
+      enum_decl = enum_decl->getDefinition();
       assert(enum_decl);
       clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
       lldb::offset_t offset = data_byte_offset;
       const int64_t enum_value = data.GetMaxU64Bitfield(
           &offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
       for (enum_pos = enum_decl->enumerator_begin(),
           enum_end_pos = enum_decl->enumerator_end();
            enum_pos != enum_end_pos; ++enum_pos) {

 }
 
 static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
                           const DataExtractor &data, lldb::offset_t byte_offset,
                           size_t byte_size, uint32_t bitfield_bit_offset,
                           uint32_t bitfield_bit_size) {
   const clang::EnumType *enutype =
       llvm::cast<clang::EnumType>(qual_type.getTypePtr());
-  const clang::EnumDecl *enum_decl = enutype->getDecl();
+  const clang::EnumDecl *enum_decl = enutype->getDecl()->getDefinition();
   assert(enum_decl);
   lldb::offset_t offset = byte_offset;
   const uint64_t enum_svalue = data.GetMaxS64Bitfield(
       &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
   bool can_be_bitfield = true;
   uint64_t covered_bits = 0;
   int num_enumerators = 0;
 
case clang::Type::ObjCInterface: {
       GetCompleteType(type);
 
       auto *objc_class_type =
           llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
       assert(objc_class_type);
       if (!objc_class_type)
         break;
       clang::ObjCInterfaceDecl *class_interface_decl =
-            objc_class_type->getInterface();
+          objc_class_type->getInterface()->getDefinition();
       if (!class_interface_decl)
         break;
       if (level == eDescriptionLevelVerbose)
         class_interface_decl->dump(llvm_ostrm);
       else
         class_interface_decl->print(llvm_ostrm,
                                     getASTContext().getPrintingPolicy(),
                                     s->GetIndentLevel());
void TypeSystemClang::CompleteObjCInterfaceDecl(
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
+/// Appends an existing declaration to the redeclaration chain.
+/// \param ts The TypeSystemClang that contains the two declarations.
+/// \param prev The most recent existing declaration.
+/// \param redecl The new declaration which should be appended to the end of
+/// redeclaration chain.
+template <typename T>
+static void ConnectRedeclToPrev(TypeSystemClang &ts, T *prev, T *redecl) {
+  assert(&ts.getASTContext() == &prev->getASTContext() && "Not ");
+  redecl->setPreviousDecl(prev);
+  // Now that the redecl chain is done, create the type explicitly via
+  // the TypeSystemClang interface that will reuse the type of the previous
+  // decl.
+  ts.GetTypeForDecl(redecl);
+  // The previous decl and the redeclaration both declare the same type.
+  assert(prev->getTypeForDecl() == redecl->getTypeForDecl());
+}
+
+/// Returns the ClangModuleID for the given declaration.
+static OptionalClangModuleID GetModuleForDecl(clang::Decl *d) {
+  if (!d->isFromASTFile() || !d->getOwningModuleID())
+    return OptionalClangModuleID();
+  return OptionalClangModuleID(d->getOwningModuleID());
+}
+
+void TypeSystemClang::CreateRedeclaration(CompilerType ct) {
+  // All the cases below just check for a specific declaration kind, create
+  // a new declaration with matching data. We don't care about metadata which
+  // should only be tracked in the first redeclaration and should be identical
+  // for all redeclarations.
+
+  if (clang::ObjCInterfaceDecl *interface = GetAsObjCInterfaceDecl(ct)) {
+    clang::NamedDecl *res = CreateObjCDecl(
+        interface->getName(), interface->getDeclContext()->getRedeclContext(),
+        GetModuleForDecl(interface), /*isForwardDecl=*/false,
+        interface->isImplicit());
+    clang::ObjCInterfaceDecl *redecl = llvm::cast<ObjCInterfaceDecl>(res);
+    ConnectRedeclToPrev(*this, interface, redecl);
+    return;
+  }
+
+  clang::TagDecl *tag_decl = ClangUtil::GetAsTagDecl(ct);
+  if (!tag_decl)
+    return;
+
+  if (clang::EnumDecl *enum_decl = dyn_cast<EnumDecl>(tag_decl)) {
+    Declaration decl;
+    clang::EnumDecl *redecl = CreateEnumerationDecl(
+        enum_decl->getNameAsString().c_str(),
+        tag_decl->getDeclContext()->getRedeclContext(),
+        GetModuleForDecl(enum_decl), decl, GetType(enum_decl->getIntegerType()),
+        enum_decl->isScoped());
+    ConnectRedeclToPrev(*this, enum_decl, redecl);
+    return;
+  }
+
+  if (auto *template_decl =
+          dyn_cast<ClassTemplateSpecializationDecl>(tag_decl)) {
+    auto redecl_info = m_class_template_redecl_infos.find(template_decl);
+    // If we are asked to redeclare a template that we haven't declared, then
+    // there is nothing we can do.
+    assert(redecl_info != m_class_template_redecl_infos.end());
+    TemplateParameterInfos template_infos = redecl_info->second.m_template_args;
+    auto *redecl = CreateClassTemplateSpecializationDecl(
+        tag_decl->getDeclContext()->getRedeclContext(),
+        GetModuleForDecl(template_decl),
+        template_decl->getSpecializedTemplate(), tag_decl->getTagKind(),
+        template_infos);
+    ConnectRedeclToPrev(*this, template_decl, redecl);
+    return;
+  }
+
+  assert(llvm::isa<RecordDecl>(tag_decl));
+  clang::NamedDecl *redecl_record = CreateRecordDecl(
+      tag_decl->getDeclContext()->getRedeclContext(),
+      GetModuleForDecl(tag_decl), lldb::eAccessPublic, tag_decl->getName(),
+      tag_decl->getTagKind(), eLanguageTypeC_plus_plus, nullptr);
+  clang::TagDecl *redecl = llvm::cast<TagDecl>(redecl_record);
+  ConnectRedeclToPrev(*this, tag_decl, redecl);
+  return;
+}
+
 DWARFASTParser *TypeSystemClang::GetDWARFParser() {
   if (!m_dwarf_ast_parser_up)
     m_dwarf_ast_parser_up = std::make_unique<DWARFASTParserClang>(*this);
   return m_dwarf_ast_parser_up.get();
 }
 
 PDBASTParser *TypeSystemClang::GetPDBParser() {
   if (!m_pdb_ast_parser_up)

lldb/unittests/CMakeLists.txt

 add_subdirectory(Language)
 add_subdirectory(ObjectFile)
 add_subdirectory(Platform)
 add_subdirectory(Process)
 add_subdirectory(ScriptInterpreter)
 add_subdirectory(Signals)
 add_subdirectory(Symbol)
 add_subdirectory(SymbolFile)
+add_subdirectory(TypeSystem)
 add_subdirectory(Target)
 add_subdirectory(tools)
 add_subdirectory(UnwindAssembly)
 add_subdirectory(Utility)
 add_subdirectory(Thread)
 
 if(LLDB_CAN_USE_DEBUGSERVER AND LLDB_TOOL_DEBUGSERVER_BUILD AND NOT LLDB_USE_SYSTEM_DEBUGSERVER)
   add_subdirectory(debugserver)
 endif()

lldb/unittests/TypeSystem/CMakeLists.txt

+add_subdirectory(Clang)

lldb/unittests/TypeSystem/Clang/CMakeLists.txt

+add_lldb_unittest(TypeSystemClangTests
+  TestClangRedeclarations.cpp
+
+  LINK_LIBS
+    lldbHost
+    lldbSymbol
+    lldbUtilityHelpers
+    lldbPluginObjectFileELF
+    lldbPluginObjectFileMachO
+    lldbPluginSymbolFileDWARF
+    lldbPluginSymbolFileSymtab
+    lldbPluginTypeSystemClang
+    LLVMTestingSupport
+  )

lldb/unittests/TypeSystem/Clang/TestClangRedeclarations.cpp

+//===-- TestClangRedeclarations.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/ExpressionParser/Clang/ClangASTMetadata.h"
+#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "TestingSupport/SubsystemRAII.h"
+#include "TestingSupport/Symbol/ClangTestUtils.h"
+#include "lldb/Core/Declaration.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostInfo.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
+#include "gtest/gtest.h"
+
+using namespace clang;
+using namespace lldb;
+using namespace lldb_private;
+
+struct TestClangRedeclarations : public testing::Test {
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
+
+  void SetUp() override {
+    m_ast.reset(
+        new TypeSystemClang("test ASTContext", HostInfo::GetTargetTriple()));
+  }
+
+  void TearDown() override { m_ast.reset(); }
+
+  std::unique_ptr<TypeSystemClang> m_ast;
+};
+
+TEST_F(TestClangRedeclarations, RedeclareCppClass) {
+  // Test redeclaring C++ classes.
+
+  OptionalClangModuleID module_id(1);
+  CompilerType class_type = m_ast->CreateRecordType(
+      m_ast->GetTranslationUnitDecl(), module_id, lldb::eAccessNone, "A",
+      TTK_Class, lldb::eLanguageTypeC_plus_plus);
+  auto *record = llvm::cast<CXXRecordDecl>(ClangUtil::GetAsTagDecl(class_type));
+
+  m_ast->CreateRedeclaration(class_type);
+  m_ast->StartTagDeclarationDefinition(class_type);
+  // For C++ classes, the definition is already available (but it is currently
+  // being defined). Make sure the definition is last in the redecl chain.
+  CXXRecordDecl *def = record->getDefinition();
+  ASSERT_TRUE(def);
+  ASSERT_TRUE(def->isBeingDefined());
+  ASSERT_NE(def, record);
+  EXPECT_EQ(def->getPreviousDecl(), record);
+
+  // Add a method.
+  std::vector<CompilerType> args;
+  CompilerType func_type =
+      m_ast->CreateFunctionType(m_ast->GetBasicType(lldb::eBasicTypeInt),
+                                args.data(), args.size(), /*is_variadic=*/false,
+                                /*type_quals=*/0, clang::CallingConv::CC_C);
+  const bool is_virtual = false;
+  const bool is_static = false;
+  const bool is_inline = false;
+  const bool is_explicit = false;
+  const bool is_attr_used = false;
+  const bool is_artificial = false;
+  clang::CXXMethodDecl *method = m_ast->AddMethodToCXXRecordType(
+      class_type.GetOpaqueQualType(), "A", nullptr, func_type,
+      lldb::eAccessPublic, is_virtual, is_static, is_inline, is_explicit,
+      is_attr_used, is_artificial);
+  // Check that the method was created and is in the definition.
+  ASSERT_NE(method, nullptr);
+  EXPECT_EQ(method->getParent(), def);
+
+  // Add an ivar and check that it was added to the definition.
+  FieldDecl *member_var = m_ast->AddFieldToRecordType(
+      class_type, "f", m_ast->GetBasicType(lldb::eBasicTypeInt),
+      lldb::eAccessPublic,
+      /*bitfield_bit_size=*/0);
+  ASSERT_TRUE(member_var);
+  EXPECT_EQ(member_var->getParent(), def);
+
+  // Complete the class and check that the last decl is the definition.
+  m_ast->CompleteTagDeclarationDefinition(class_type);
+  EXPECT_FALSE(record->isThisDeclarationADefinition());
+  EXPECT_TRUE(def->isThisDeclarationADefinition());
+  // Check that the module is identical.
+  EXPECT_EQ(def->getOwningModuleID(), module_id.GetValue());
+
+  // Make sure forward decl and definition have the same type.
+  EXPECT_EQ(def->getTypeForDecl(), record->getTypeForDecl());
+}
+
+TEST_F(TestClangRedeclarations, RedeclareCppTemplateClass) {
+  // Test redeclaring C++ template classes.
+
+  OptionalClangModuleID module_id(1);
+  auto args = std::make_unique<TypeSystemClang::TemplateParameterInfos>();
+  args->args.push_back(TemplateArgument(m_ast->getASTContext().IntTy));
+  args->names.push_back("T");
+
+  ClassTemplateDecl *template_decl =
+      m_ast->CreateClassTemplateDecl(m_ast->GetTranslationUnitDecl(), module_id,
+                                     lldb::eAccessNone, "A", TTK_Struct, *args);
+  ClassTemplateSpecializationDecl *fwd_decl =
+      m_ast->CreateClassTemplateSpecializationDecl(
+          m_ast->GetTranslationUnitDecl(), module_id, template_decl, TTK_Struct,
+          *args);
+  CompilerType spec_type =
+      m_ast->CreateClassTemplateSpecializationType(fwd_decl);
+
+  // Delete the TemplateParameterInfos to make sure TypeSystemClang doesn't
+  // rely on the caller to keep them around.
+  args.reset();
+
+  m_ast->CreateRedeclaration(spec_type);
+  m_ast->StartTagDeclarationDefinition(spec_type);
+  // For C++ classes, the definition is already available (but it is currently
+  // being defined). Make sure the definition is last in the redecl chain.
+  CXXRecordDecl *def = fwd_decl->getDefinition();
+  ASSERT_TRUE(def);
+  ASSERT_TRUE(def->isBeingDefined());
+  ASSERT_NE(def, fwd_decl);
+  EXPECT_EQ(def->getPreviousDecl(), fwd_decl);
+
+  // Add an ivar and check that it was added to the definition.
+  FieldDecl *member_var = m_ast->AddFieldToRecordType(
+      spec_type, "f", m_ast->GetBasicType(lldb::eBasicTypeInt),
+      lldb::eAccessPublic,
+      /*bitfield_bit_size=*/0);
+  ASSERT_TRUE(member_var);
+  EXPECT_EQ(member_var->getParent(), def);
+
+  // Complete the class and check that the last decl is the definition.
+  m_ast->CompleteTagDeclarationDefinition(spec_type);
+  EXPECT_FALSE(fwd_decl->isThisDeclarationADefinition());
+  EXPECT_TRUE(def->isThisDeclarationADefinition());
+
+  // Check that the module is identical.
+  EXPECT_EQ(def->getOwningModuleID(), module_id.GetValue());
+
+  // Make sure forward decl and definition have the same type.
+  EXPECT_EQ(def->getTypeForDecl(), fwd_decl->getTypeForDecl());
+}
+
+TEST_F(TestClangRedeclarations, RedeclareObjCClass) {
+  // Test redeclaring Objective-C interfaces.
+
+  OptionalClangModuleID module_id(1);
+  CompilerType objc_class =
+      m_ast->CreateObjCClass("A", m_ast->GetTranslationUnitDecl(), module_id,
+                             /*isForwardDecl=*/false,
+                             /*isInternal=*/false);
+  ObjCInterfaceDecl *interface = m_ast->GetAsObjCInterfaceDecl(objc_class);
+  m_ast->CreateRedeclaration(objc_class);
+  m_ast->StartTagDeclarationDefinition(objc_class);
+  ObjCInterfaceDecl *def = interface->getDefinition();
+  ASSERT_TRUE(def);
+  ASSERT_NE(def, interface);
+  EXPECT_EQ(def->getPreviousDecl(), interface);
+
+  // Add a method.
+  std::vector<CompilerType> args;
+  CompilerType func_type =
+      m_ast->CreateFunctionType(m_ast->GetBasicType(lldb::eBasicTypeInt),
+                                args.data(), args.size(), /*is_variadic=*/false,
+                                /*type_quals=*/0, clang::CallingConv::CC_C);
+  const bool variadic = false;
+  const bool artificial = false;
+  const bool objc_direct = false;
+  clang::ObjCMethodDecl *method = TypeSystemClang::AddMethodToObjCObjectType(
+      objc_class, "-[A foo]", func_type, lldb::eAccessPublic, artificial,
+      variadic, objc_direct);
+  // Check that the method was created and is in the definition.
+  ASSERT_NE(method, nullptr);
+  EXPECT_EQ(*def->meth_begin(), method);
+
+  // Add an ivar and check that it was added to the definition.
+  FieldDecl *ivar = m_ast->AddFieldToRecordType(
+      objc_class, "f", m_ast->GetBasicType(lldb::eBasicTypeInt),
+      lldb::eAccessPublic,
+      /*bitfield_bit_size=*/0);
+  ASSERT_TRUE(ivar);
+  EXPECT_EQ(*def->ivar_begin(), ivar);
+
+  m_ast->CompleteTagDeclarationDefinition(objc_class);
+  // The forward declaration should be unchanged.
+  EXPECT_FALSE(interface->isThisDeclarationADefinition());
+  EXPECT_TRUE(def->isThisDeclarationADefinition());
+  // Check that the module is identical.
+  EXPECT_EQ(def->getOwningModuleID(), module_id.GetValue());
+
+  // Make sure forward decl and definition have the same type.
+  EXPECT_EQ(def->getTypeForDecl(), interface->getTypeForDecl());
+}
+
+TEST_F(TestClangRedeclarations, RedeclareEnum) {
+  // Test redeclaring enums.
+
+  OptionalClangModuleID module_id(1);
+  Declaration decl;
+  CompilerType enum_type = m_ast->CreateEnumerationType(
+      "A", m_ast->GetTranslationUnitDecl(), module_id, decl,
+      m_ast->GetBasicType(lldb::eBasicTypeInt), /*is_scoped=*/true);
+
+  EnumDecl *fwd_decl = m_ast->GetAsEnumDecl(enum_type);
+  m_ast->CreateRedeclaration(enum_type);
+  m_ast->StartTagDeclarationDefinition(enum_type);
+  m_ast->AddEnumerationValueToEnumerationType(
+      enum_type, decl, "case1", /*enum_value=*/1, /*enum_value_bit_size=*/32);
+  m_ast->CompleteTagDeclarationDefinition(enum_type);
+
+  // There should now be a definition at the end of the redeclaration chain.
+  EnumDecl *def = fwd_decl->getDefinition();
+  ASSERT_TRUE(def);
+  ASSERT_NE(def, fwd_decl);
+  EXPECT_EQ(def->getPreviousDecl(), fwd_decl);
+  // The forward declaration should be unchanged.
+  EXPECT_FALSE(fwd_decl->isThisDeclarationADefinition());
+  EXPECT_TRUE(def->isThisDeclarationADefinition());
+  // Check that the module is identical.
+  EXPECT_EQ(def->getOwningModuleID(), module_id.GetValue());
+
+  // Make sure forward decl and definition have the same type.
+  EXPECT_EQ(def->getTypeForDecl(), fwd_decl->getTypeForDecl());
+
+  // Check that ForEachEnumerator uses the definition.
+  bool seen_value = false;
+  m_ast->ForEachEnumerator(enum_type.GetOpaqueQualType(),
+                           [&seen_value](const CompilerType &, ConstString name,
+                                         const llvm::APSInt &) {
+                             EXPECT_EQ(name, "case1");
+                             seen_value = true;
+                             return true;
+                           });
+  EXPECT_TRUE(seen_value);
+}
+
+TEST_F(TestClangRedeclarations, NestedDecls) {
+  // Tests that nested declarations pick the right redeclaration as their
+  // DeclContext.
+
+  // Create a class.
+  CompilerType context_class = m_ast->CreateRecordType(
+      m_ast->GetTranslationUnitDecl(), OptionalClangModuleID(),
+      lldb::eAccessNone, "A", TTK_Class, lldb::eLanguageTypeC_plus_plus);
+  auto *fwd_decl =
+      llvm::cast<CXXRecordDecl>(ClangUtil::GetAsTagDecl(context_class));
+
+  // Give it a redeclaration that defines it.
+  m_ast->CreateRedeclaration(context_class);
+  m_ast->StartTagDeclarationDefinition(context_class);
+  m_ast->CompleteTagDeclarationDefinition(context_class);
+
+  // Check that there is one forward declaration and a definition now.
+  CXXRecordDecl *def = fwd_decl->getDefinition();
+  ASSERT_TRUE(def);
+  EXPECT_FALSE(fwd_decl->isThisDeclarationADefinition());
+  EXPECT_TRUE(def->isThisDeclarationADefinition());
+
+  // Create a nested class and make sure it picks the definition as its
+  // DeclContext.
+  CompilerType nested_class = m_ast->CreateRecordType(
+      fwd_decl, OptionalClangModuleID(), lldb::eAccessPublic, "A", TTK_Class,
+      lldb::eLanguageTypeC_plus_plus);
+  EXPECT_EQ(ClangUtil::GetAsTagDecl(nested_class)->getDeclContext(), def);
+
+  CompilerType int_type = m_ast->GetBasicType(lldb::eBasicTypeInt);
+
+  // Create a typedef and make sure it picks the definition as its DeclContext.
+  CompilerType nested_typedef = int_type.CreateTypedef(
+      "t",
+      CompilerDeclContext(m_ast.get(), static_cast<DeclContext *>(fwd_decl)),
+      /*payload=*/0);
+  const TypedefType *typedef_type =
+      ClangUtil::GetQualType(nested_typedef)->getAs<TypedefType>();
+  ASSERT_TRUE(typedef_type);
+  TypedefNameDecl *nested_typedef_decl = typedef_type->getDecl();
+  ASSERT_TRUE(nested_typedef_decl);
+  EXPECT_EQ(nested_typedef_decl->getDeclContext(), def);
+
+  TypeSystemClang::TemplateParameterInfos args;
+  args.args.push_back(TemplateArgument(m_ast->getASTContext().IntTy));
+  args.names.push_back("T");
+
+  // Create a class template and specialization and check that their DeclContext
+  // is the definition.
+  ClassTemplateDecl *template_decl = m_ast->CreateClassTemplateDecl(
+      fwd_decl, OptionalClangModuleID(), lldb::eAccessPublic, "A", TTK_Struct,
+      args);
+  EXPECT_EQ(template_decl->getDeclContext(), def);
+  ClassTemplateSpecializationDecl *template_spec_decl =
+      m_ast->CreateClassTemplateSpecializationDecl(
+          fwd_decl, OptionalClangModuleID(), template_decl, TTK_Struct, args);
+  EXPECT_EQ(template_spec_decl->getDeclContext(), def);
+}
+
+TEST_F(TestClangRedeclarations, MetadataRedeclaration) {
+  // Tests that metadata is shared between redeclarations.
+
+  // Create a class with the test metadata.
+  CompilerType class_with_metadata = m_ast->CreateRecordType(
+      m_ast->GetTranslationUnitDecl(), OptionalClangModuleID(),
+      lldb::eAccessPublic, "A", TTK_Class, lldb::eLanguageTypeC_plus_plus);
+  auto *record =
+      llvm::cast<CXXRecordDecl>(ClangUtil::GetAsTagDecl(class_with_metadata));
+  ClangASTMetadata metadata;
+  metadata.SetUserID(1234);
+  m_ast->SetMetadata(record, metadata);
+  ASSERT_EQ(m_ast->GetMetadata(record)->GetUserID(), 1234U);
+
+  // Redeclare and define the redeclaration.
+  m_ast->CreateRedeclaration(class_with_metadata);
+  m_ast->StartTagDeclarationDefinition(class_with_metadata);
+  m_ast->CompleteTagDeclarationDefinition(class_with_metadata);
+  CXXRecordDecl *def = record->getDefinition();
+  ASSERT_TRUE(def);
+  ASSERT_NE(def, record);
+  EXPECT_EQ(def->getPreviousDecl(), record);
+
+  // Check that the redeclaration has the right metadata;
+  ASSERT_TRUE(m_ast->GetMetadata(def));
+  EXPECT_EQ(m_ast->GetMetadata(def)->GetUserID(), 1234U);
+}