[lldb][WIP] Use forward decls with redeclared definitions instead of minimal import for records

[teemperor]

Summary

This patch is rewriting the way we move Clang types between different ASTS in Clang.

The motivation is that the current approach for 'completing types' in LLDB just doesn't work. We have all kinds of situations where we either have Clang crash due to for example having a Record without DefinitionData but with FieldDecls in it.

The reason for that is that at the moment we create record types ([CXX]RecordDecls and ObjCInterfaceDecls) and we always pretend that a type potentially has a definition that somehow could be lazily pulled in. However, Clang doesn't have any interface (at least none that is consistently called) that turns a RecordDecl without DefinitionData into a RecordDecl with DefinitionData. The only relevant API in the ExternalASTSource is CompleteType is suffering from the fact that it's essentially not used by generic Clang code.

The part of the ExternalASTSource API that is consistently called to pull in a potential definition is CompleteRedeclChain (which is for example automatically called when calling getDefinition on a RecordDecl). The problem with CompleteRedeclChain however is that it's not supposed to add definition data to the Decl its called on, but instead it should provide a redeclaration that is defining the record. That's a very different system than what we currently have and we can't just swap it out under the hood.

To make it short: We probably need to rewrite that part of LLDB.

So the solution here is essentially rewriting all our completion code to do this:

1. Instead of creating these weirdly defined records that have fields but maybe not definition and so on, we only create forward decls at the start.
2. We then bump the GenerationCounter of the ExternalASTSource of the current AST to force rebuilding of the redeclaration chain.
3. When Clang asks for the definition of the record, it will ask the ExternalASTSource to complete the redeclaration chain. At this point we build the definition and add it as a second decl.

The ASTImporter can now also stop using the minimal mode for records as there is no reason anymore. It just imports first the forward declaration and then the definition when needed.

[teemperor]

• Add a second DIEtoX map from DIEs to records (and their definitions once we have them).
• Avoid some calls that try to find the 'interesting' TagDecl redeclaration.

[martong]

This is a great initiative! Finally, the CTU analysis code and LLDB could share a simplified ASTImporter. In the past years we've seen that the minimal import mode caused many corner cases in the ASTImporter and complicated the code pretty much.

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

272

[teemperor]

Just to clarify because Jan abandoned the linked ASTImporter patch: I don't have a timeline for this. If I find the time to work on this then this might land quite soon or maybe it will only land in a few months. Or I'll run into something serious that just won't work with this approach and we have to abandon this.

[teemperor]

• All C tests are passing.
• Nearly all Obj-C tests are passing.
• about 70% of the C++ tests are passing now.

[teemperor]

Just moving this out of the review queue. Also as there are a bunch of Clang changes (that probably trigger a ton of Herald rules), I keep pushing new updates to https://github.com/teemperor/llvm-project/tree/Rewrite until I can split all those changes out into their own smaller patches.

[dblaikie]

Just want to say this sounds like a really great direction - putting lldb in a codepath that's much more robustly tested (by lazy loading modules during normal compilation) than the "let's create interesting incomplete types in ways Clang Sema never expects, and then try to patch up all the holes where Clang assumes the type must be complete". Really looking forward to this & hope it provides the sort of robustness improvements it sounds like it should.

[teemperor]

• Update from git

[martong]

@JDevlieghere @labath Do you know if someone took it over from @teemperor (since AFAIK he is no longer working on lldb) ? Are there any plans to continue this effort? I am interested as a clang::ASTImporter maintainer, we could have so many simplifications in clang::ASTImporter if this patch will have been landed sometime.

[JDevlieghere]

In D101950#3418751, @martong wrote:

@JDevlieghere @labath Do you know if someone took it over from @teemperor (since AFAIK he is no longer working on lldb) ? Are there any plans to continue this effort? I am interested as a clang::ASTImporter maintainer, we could have so many simplifications in clang::ASTImporter if this patch will have been landed sometime.

Yup. We've hired someone new to work on the expression evaluator in LLDB but that person hasn't started yet and will need some time to ramp up. I'll sync with @aprantl and see if this is something we can prioritize.

clang/lib/AST/ASTImporter.cpp

Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
       const FunctionDecl *Definition = nullptr;
       if (D->doesThisDeclarationHaveABody() &&
           FoundFunction->hasBody(Definition))
         return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
       return nullptr;
     }
 
     void addDeclToContexts(Decl *FromD, Decl *ToD) {
-      if (Importer.isMinimalImport()) {
+      if (Importer.isMinimalImport() || Importer.getToContext().getLangOpts().DebuggerSupport || Importer.getFromContext().getLangOpts().DebuggerSupport) {
         // In minimal import case the decl must be added even if it is not
         // contained in original context, for LLDB compatibility.
         // FIXME: Check if a better solution is possible.
         if (!FromD->getDescribedTemplate() &&
             FromD->getFriendObjectKind() == Decl::FOK_None)
           ToD->getLexicalDeclContext()->addDeclInternal(ToD);
         return;
       }
bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
   else
     return !Found->isInAnonymousNamespace() &&
            !Found->hasExternalFormalLinkage();
 }
 
 template <>
 bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
                                                TypedefNameDecl *From) {
-  if (Found->getLinkageInternal() != From->getLinkageInternal())
-    return false;
+  //if (Found->getLinkageInternal() != From->getLinkageInternal())
+  //  return false;
 
   if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
     return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
   return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
 }
 
 } // namespace clang
 
enum {
     TypeAlignment = 1 << TypeAlignmentInBits
   };
 
   return QualType(new (Importer.getToContext(), TypeAlignment)
                   InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
 }
 
 ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
-  Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
+  Expected<RecordDecl *> ToDeclOrErr = import(T->getCanonicalDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
 
   return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
 }
 
 ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
   Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
if (!FromD)
     return Error::success();
 
   if (!ToD)
     if (Error Err = importInto(ToD, FromD))
       return Err;
 
   if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
     if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
-      if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
-          !ToRecord->getDefinition()) {
-        if (Error Err = ImportDefinition(FromRecord, ToRecord))
+      if (FromRecord->getDefinition() && !ToRecord->getDefinition()) {
+        if (Error Err = ImportDefinition(FromRecord->getDefinition(), ToRecord))
           return Err;
       }
     }
     return Error::success();
   }
 
   if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
     if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
case DeclarationName::CXXConversionFunctionName: {
     return Error::success();
   }
   }
   llvm_unreachable("Unknown name kind.");
 }
 
 Error
 ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
-  if (Importer.isMinimalImport() && !ForceImport) {
+  if (Importer.isMinimalImport() && !ForceImport && isa<NamespaceDecl>(FromDC)) {
     auto ToDCOrErr = Importer.ImportContext(FromDC);
     return ToDCOrErr.takeError();
   }
 
   // We use strict error handling in case of records and enums, but not
   // with e.g. namespaces.
   //
   // FIXME Clients of the ASTImporter should be able to choose an
auto DefinitionCompleter = [To]() {
     // importDefinition is called from LLDB, which tries to get the members, so
     // when we get here, the class already has the DefinitionData set, so we
     // must unset the CompleteDefinition here to be able to complete again the
     // definition.
     To->setCompleteDefinition(false);
     To->completeDefinition();
   };
 
-  if (To->getDefinition() || To->isBeingDefined()) {
+  if (To->isThisDeclarationADefinition() || To->isBeingDefined()) {
     if (Kind == IDK_Everything ||
         // In case of lambdas, the class already has a definition ptr set, but
         // the contained decls are not imported yet. Also, isBeingDefined was
         // set in CXXRecordDecl::CreateLambda.  We must import the contained
         // decls here and finish the definition.
         (To->isLambda() && shouldForceImportDeclContext(Kind))) {
       if (To->isLambda()) {
         auto *FromCXXRD = cast<CXXRecordDecl>(From);
for (auto *FoundDecl : FoundDecls) {
         continue;
       if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
         if (!hasSameVisibilityContextAndLinkage(FoundTypedef, D))
           continue;
 
         QualType FromUT = D->getUnderlyingType();
         QualType FoundUT = FoundTypedef->getUnderlyingType();
         if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) {
+          if (Importer.isMinimalImport())
+            return Importer.MapImported(D, FoundTypedef);
           // If the "From" context has a complete underlying type but we
           // already have a complete underlying type then return with that.
           if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
             return Importer.MapImported(D, FoundTypedef);
           // FIXME Handle redecl chain. When you do that make consistent changes
           // in ASTImporterLookupTable too.
         } else {
           ConflictingDecls.push_back(FoundDecl);
if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
     if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
       D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
     else
       return POIOrErr.takeError();
   }
 
   // Import the definition
   if (D->isCompleteDefinition())
-    if (Error Err = ImportDefinition(D, D2))
+    if (Error Err = ImportDefinition(D, D2, IDK_Everything))
       return std::move(Err);
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
   bool IsFriendTemplate = false;
   if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
for (auto *FoundDecl : FoundDecls) {
         if (!SearchName)
           if (!IsStructuralMatch(D, FoundRecord, false))
             continue;
 
         if (!hasSameVisibilityContextAndLinkage(FoundRecord, D))
           continue;
 
         if (IsStructuralMatch(D, FoundRecord)) {
-          RecordDecl *FoundDef = FoundRecord->getDefinition();
-          if (D->isThisDeclarationADefinition() && FoundDef) {
+          RecordDecl *FoundDef = nullptr; //FoundRecord->getDefinition();
+          if (false && D->isThisDeclarationADefinition() && FoundDef) {
             // FIXME: Structural equivalence check should check for same
             // user-defined methods.
             Importer.MapImported(D, FoundDef);
             if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
               auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
               assert(FoundCXX && "Record type mismatch");
 
               if (!Importer.isMinimalImport())
if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
     D2->setQualifierInfo(*QualifierLocOrErr);
   else
     return QualifierLocOrErr.takeError();
 
   if (D->isAnonymousStructOrUnion())
     D2->setAnonymousStructOrUnion(true);
 
   if (D->isCompleteDefinition())
-    if (Error Err = ImportDefinition(D, D2, IDK_Default))
+    if (Error Err = ImportDefinition(D, D2, IDK_Everything))
       return std::move(Err);
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   // Import the major distinguishing characteristics of this enumerator.
   DeclContext *DC, *LexicalDC;
if ((bool)FromSuper != (bool)ToSuper ||
         Importer.FromDiag(From->getSuperClassLoc(),
                           diag::note_odr_objc_superclass)
         << From->getSuperClass()->getDeclName();
       else
         Importer.FromDiag(From->getLocation(),
                           diag::note_odr_objc_missing_superclass);
     }
 
-    if (shouldForceImportDeclContext(Kind))
-      if (Error Err = ImportDeclContext(From))
-        return Err;
     return Error::success();
   }
 
   // Start the definition.
   To->startDefinition();
 
   // If this class has a superclass, import it.
   if (From->getSuperClass()) {
if (auto POIOrErr = import(D->getPointOfInstantiation()))
       D2->setPointOfInstantiation(*POIOrErr);
     else
       return POIOrErr.takeError();
   }
 
   D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
 
   if (D->isCompleteDefinition())
-    if (Error Err = ImportDefinition(D, D2))
+    if (Error Err = ImportDefinition(D, D2, IDK_Everything))
       return std::move(Err);
 
   return D2;
 }
 
 ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
   // Import the major distinguishing characteristics of this variable template.
   DeclContext *DC, *LexicalDC;
void ASTImporter::CompleteDecl (Decl *D) {
   }
   else {
     assert(0 && "CompleteDecl called on a Decl that can't be completed");
   }
 }
 
 Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
+  if (!(Pos == ImportedDecls.end() || Pos->second == To)) {
+    From->dumpColor();
+    To->dumpColor();
+    Pos->second->dumpColor();
+  }
   assert((Pos == ImportedDecls.end() || Pos->second == To) &&
       "Try to import an already imported Decl");
   if (Pos != ImportedDecls.end())
     return Pos->second;
   ImportedDecls[From] = To;
   // This mapping should be maintained only in this function. Therefore do not
   // check for additional consistency.
   ImportedFromDecls[To] = From;

clang/lib/AST/ASTStructuralEquivalence.cpp

static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   // If one is a class template specialization and the other is not, these
   // structures are different.
   else if (Spec1 || Spec2)
     return false;
 
   // Compare the definitions of these two records. If either or both are
   // incomplete (i.e. it is a forward decl), we assume that they are
   // equivalent.
-  D1 = D1->getDefinition();
-  D2 = D2->getDefinition();
-  if (!D1 || !D2)
+  if (!D1->isThisDeclarationADefinition() || !D2->isThisDeclarationADefinition())
     return true;
 
   // If any of the records has external storage and we do a minimal check (or
   // AST import) we assume they are equivalent. (If we didn't have this
   // assumption then `RecordDecl::LoadFieldsFromExternalStorage` could trigger
   // another AST import which in turn would call the structural equivalency
   // check again and finally we'd have an improper result.)
   if (Context.EqKind == StructuralEquivalenceKind::Minimal)

clang/lib/AST/DeclObjC.cpp

ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
                                              IdentifierInfo *Id,
                                              ObjCTypeParamList *typeParamList,
                                              ObjCInterfaceDecl *PrevDecl,
                                              SourceLocation ClassLoc,
                                              bool isInternal){
   auto *Result = new (C, DC)
       ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
                         isInternal);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getLangOpts().Modules && !C.getLangOpts().DebuggerSupport);
   C.getObjCInterfaceType(Result, PrevDecl);
   return Result;
 }
 
 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                          unsigned ID) {
   auto *Result = new (C, ID)
       ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
                         SourceLocation(), nullptr, false);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(false);
   return Result;
 }
 
 ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
                                      SourceLocation AtLoc, IdentifierInfo *Id,
                                      ObjCTypeParamList *typeParamList,
                                      SourceLocation CLoc,
                                      ObjCInterfaceDecl *PrevDecl,

clang/lib/AST/TextNodeDumper.cpp

for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
              const_cast<NamedDecl *>(ND)))
       AddChild([=] { OS << "also in " << M->getFullModuleName(); });
   if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
     if (!ND->isUnconditionallyVisible())
       OS << " hidden";
   if (D->isImplicit())
     OS << " implicit";
 
-  if (D->isUsed())
+  if (/*REMOVE ME after D80878 */ false && D->isUsed())
     OS << " used";
   else if (D->isThisDeclarationReferenced())
     OS << " referenced";
 
   if (D->isInvalidDecl())
     OS << " invalid";
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isConstexprSpecified())

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

public:
   clang::Decl *GetExternalDecl(uint32_t ID) override {
     for (size_t i = 0; i < Sources.size(); ++i)
       if (clang::Decl *Result = Sources[i]->GetExternalDecl(ID))
         return Result;
     return nullptr;
   }
 
   void CompleteRedeclChain(const clang::Decl *D) override {
-    for (size_t i = 0; i < Sources.size(); ++i)
+    for (size_t i = 0; i < Sources.size(); ++i) {
       Sources[i]->CompleteRedeclChain(D);
+      if (auto *td = llvm::dyn_cast<clang::TagDecl>(D))
+        if (td->getDefinition())
+          return;
+    }
   }
 
   clang::Selector GetExternalSelector(uint32_t ID) override {
     clang::Selector Sel;
     for (size_t i = 0; i < Sources.size(); ++i) {
       Sel = Sources[i]->GetExternalSelector(ID);
       if (!Sel.isNull())
         return Sel;

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.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"
 
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h" //remove me
+
 #include "Plugins/ExpressionParser/Clang/CxxModuleHandler.h"
+#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 
 class ClangASTMetadata;
 class TypeSystemClang;
 
public:
 
   /// 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);
+  void SetRecordLayout(const clang::RecordDecl *decl, const LayoutInfo &layout);
+
+  bool HasRecordLayout(const clang::RecordDecl *decl);
 
   bool 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);
 
+  bool CanImport(clang::Decl *d);
+
   /// Returns true iff the given type was copied from another TypeSystemClang
   /// and the original type in this other TypeSystemClang might contain
   /// additional information (e.g., the definition of a 'class' type) that could
   /// be imported.
   ///
   /// \see ClangASTImporter::Import
   bool CanImport(const CompilerType &type);
 
   /// If the given type was copied from another TypeSystemClang then copy over
   /// all missing information (e.g., the definition of a 'class' type).
   ///
   /// \return True iff an original type in another TypeSystemClang was found.
   ///         Note: Does *not* return false if an original type was found but
   ///               no information was imported over.
   ///
   /// \see ClangASTImporter::Import
   bool Import(const CompilerType &type);
 
   bool CompleteType(const CompilerType &compiler_type);
 
-  bool CompleteTagDecl(clang::TagDecl *decl);
+  bool CompleteTagDecl(const clang::TagDecl *decl);
 
-  bool CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin);
+  bool CompleteTagDeclWithOrigin(const clang::TagDecl *decl, clang::TagDecl *origin);
 
-  bool CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *interface_decl);
+  bool CompleteObjCInterfaceDecl(const clang::ObjCInterfaceDecl *interface_decl);
 
   bool CompleteAndFetchChildren(clang::QualType type);
 
   bool RequireCompleteType(clang::QualType type);
 
   /// Updates the internal origin-tracking information so that the given
   /// 'original' decl is from now on used to import additional information
   /// into the given decl.
public:
   ///
   /// When intercepting a declaration import, the ASTImporterDelegate uses the
   /// CxxModuleHandler to replace any missing or malformed declarations with
   /// their counterpart from a C++ module.
   struct ASTImporterDelegate : public clang::ASTImporter {
     ASTImporterDelegate(ClangASTImporter &master, clang::ASTContext *target_ctx,
                         clang::ASTContext *source_ctx)
         : clang::ASTImporter(*target_ctx, master.m_file_manager, *source_ctx,
                              master.m_file_manager, true /*minimal*/),
           m_master(master), m_source_ctx(source_ctx) {
       // Target and source ASTContext shouldn't be identical. Importing AST
       // nodes within the same AST doesn't make any sense as the whole idea
       // is to import them to a different AST.
       lldbassert(target_ctx != source_ctx && "Can't import into itself");
       // This is always doing a minimal import of any declarations. This means
       // that there has to be an ExternalASTSource in the target ASTContext
       // (that should implement the callbacks that complete any declarations
public:
 
     NamespaceMetaMap m_namespace_maps;
     MapCompleter *m_map_completer = nullptr;
 
     /// Sets the DeclOrigin for the given Decl and overwrites any existing
     /// DeclOrigin.
     void setOrigin(const clang::Decl *decl, DeclOrigin origin) {
       // Setting the origin of any decl to itself (or to a different decl
-      // in the same ASTContext) doesn't make any sense. It will also cause
-      // ASTImporterDelegate::ImportImpl to infinite recurse when trying to find
-      // the 'original' Decl when importing code.
+      // in the same ASTContext) doesn't make any sense.
       assert(&decl->getASTContext() != origin.ctx &&
              "Trying to set decl origin to its own ASTContext?");
       assert(decl != origin.decl && "Trying to set decl origin to itself?");
       m_origins[decl] = origin;
     }
 
     /// Removes any tracked DeclOrigin for the given decl.
-    void removeOrigin(const clang::Decl *decl) { m_origins.erase(decl); }
+    void removeOrigin(const clang::Decl *decl) {
+      m_origins.erase(decl);
+    }
 
     /// Remove all DeclOrigin entries that point to the given ASTContext.
     /// Useful when an ASTContext is about to be deleted and all the dangling
     /// pointers to it need to be removed.
     void removeOriginsWithContext(clang::ASTContext *ctx) {
       for (OriginMap::iterator iter = m_origins.begin();
            iter != m_origins.end();) {
         if (iter->second.ctx == ctx)

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

public:
   virtual ~CompleteTagDeclsScope() {
     ClangASTImporter::ASTContextMetadataSP to_context_md =
         importer.GetContextMetadata(m_dst_ctx);
 
     // Complete all decls we collected until now.
     while (!m_decls_to_complete.empty()) {
       NamedDecl *decl = m_decls_to_complete.pop_back_val();
       m_decls_already_completed.insert(decl);
-
-      // The decl that should be completed has to be imported into the target
-      // context from some other context.
-      assert(to_context_md->hasOrigin(decl));
-      // We should only complete decls coming from the source context.
-      assert(to_context_md->getOrigin(decl).ctx == m_src_ctx);
-
-      Decl *original_decl = to_context_md->getOrigin(decl).decl;
-
-      // Complete the decl now.
-      TypeSystemClang::GetCompleteDecl(m_src_ctx, original_decl);
-      if (auto *tag_decl = dyn_cast<TagDecl>(decl)) {
-        if (auto *original_tag_decl = dyn_cast<TagDecl>(original_decl)) {
-          if (original_tag_decl->isCompleteDefinition()) {
-            m_delegate->ImportDefinitionTo(tag_decl, original_tag_decl);
-            tag_decl->setCompleteDefinition(true);
-          }
-        }
-
-        tag_decl->setHasExternalLexicalStorage(false);
-        tag_decl->setHasExternalVisibleStorage(false);
-      } else if (auto *container_decl = dyn_cast<ObjCContainerDecl>(decl)) {
-        container_decl->setHasExternalLexicalStorage(false);
-        container_decl->setHasExternalVisibleStorage(false);
-      }
-
       to_context_md->removeOrigin(decl);
     }
 
     // Stop listening to imported decls. We do this after clearing the
     // Decls we needed to import to catch all Decls they might have pulled in.
     m_delegate->RemoveImportListener();
   }
 
   void NewDeclImported(clang::Decl *from, clang::Decl *to) override {
     // Filter out decls that we can't complete later.
     if (!isa<TagDecl>(to) && !isa<ObjCInterfaceDecl>(to))
       return;
+
+    to = ClangUtil::GetFirstDecl(to);
+
     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())
       return;
 
     NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);
     // Check if we already completed this type.
     if (m_decls_already_completed.count(to_named_decl) != 0)
clang::Decl *ClangASTImporter::DeportDecl(clang::ASTContext *dst_ctx,
   LLDB_LOG(log,
            "    [ClangASTImporter] DeportDecl deported ({0}Decl*){1} to "
            "({2}Decl*){3}",
            decl->getDeclKindName(), decl, result->getDeclKindName(), result);
 
   return result;
 }
 
+bool ClangASTImporter::CanImport(Decl *d) {
+  if (!d)
+    return false;
+  if (isa<TagDecl>(d))
+    return GetDeclOrigin(d).Valid();
+  if (isa<ObjCInterfaceDecl>(d))
+    return GetDeclOrigin(d).Valid();
+  return false;
+}
+
 bool ClangASTImporter::CanImport(const CompilerType &type) {
   if (!ClangUtil::IsClangType(type))
     return false;
 
   clang::QualType qual_type(
       ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
-  case clang::Type::Record: {
-    const clang::CXXRecordDecl *cxx_record_decl =
-        qual_type->getAsCXXRecordDecl();
-    if (cxx_record_decl) {
-      if (GetDeclOrigin(cxx_record_decl).Valid())
-        return true;
-    }
-  } break;
+  case clang::Type::Record:
+    return CanImport(qual_type->getAsRecordDecl());
 
-  case clang::Type::Enum: {
-    clang::EnumDecl *enum_decl =
-        llvm::cast<clang::EnumType>(qual_type)->getDecl();
-    if (enum_decl) {
-      if (GetDeclOrigin(enum_decl).Valid())
-        return true;
-    }
-  } break;
+  case clang::Type::Enum:
+    return CanImport(llvm::cast<clang::EnumType>(qual_type)->getDecl());
 
   case clang::Type::ObjCObject:
   case clang::Type::ObjCInterface: {
     const clang::ObjCObjectType *objc_class_type =
         llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
       // We currently can't complete objective C types through the newly added
       // ASTContext because it only supports TagDecl objects right now...
-      if (class_interface_decl) {
-        if (GetDeclOrigin(class_interface_decl).Valid())
-          return true;
-      }
+      return CanImport(class_interface_decl);
     }
   } break;
 
   case clang::Type::Typedef:
     return CanImport(CompilerType(type.GetTypeSystem(),
                                   llvm::cast<clang::TypedefType>(qual_type)
                                       ->getDecl()
                                       ->getUnderlyingType()
bool ClangASTImporter::Import(const CompilerType &type) {
   }
   return false;
 }
 
 bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) {
   if (!CanImport(compiler_type))
     return false;
 
-  if (Import(compiler_type)) {
-    TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
-    return true;
-  }
-
-  TypeSystemClang::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
-                                         false);
-  return false;
+  return Import(compiler_type);
 }
 
 bool ClangASTImporter::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) {
+  record_decl = static_cast<const RecordDecl*>(record_decl->getFirstDecl());
   RecordDeclToLayoutMap::iterator pos =
       m_record_decl_to_layout_map.find(record_decl);
   bool success = false;
   base_offsets.clear();
   vbase_offsets.clear();
   if (pos != m_record_decl_to_layout_map.end()) {
     bit_size = pos->second.bit_size;
     alignment = pos->second.alignment;
     field_offsets.swap(pos->second.field_offsets);
     base_offsets.swap(pos->second.base_offsets);
     vbase_offsets.swap(pos->second.vbase_offsets);
-    m_record_decl_to_layout_map.erase(pos);
     success = true;
   } else {
     bit_size = 0;
     alignment = 0;
     field_offsets.clear();
   }
   return success;
 }
 
-void ClangASTImporter::SetRecordLayout(clang::RecordDecl *decl,
+void ClangASTImporter::SetRecordLayout(const clang::RecordDecl *decl,
                                         const LayoutInfo &layout) {
+  decl = static_cast<const RecordDecl*>(decl->getFirstDecl());
+
+  assert(m_record_decl_to_layout_map.count(decl) == 0 && "Trying to overwrite layout?");
   m_record_decl_to_layout_map.insert(std::make_pair(decl, layout));
 }
 
-bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) {
+bool ClangASTImporter::HasRecordLayout(const RecordDecl *decl) {
+  decl = static_cast<const RecordDecl*>(decl->getFirstDecl());
+  return m_record_decl_to_layout_map.count(decl);
+}
+
+bool ClangASTImporter::CompleteTagDecl(const TagDecl *decl) {
   DeclOrigin decl_origin = GetDeclOrigin(decl);
 
   if (!decl_origin.Valid())
     return false;
 
-  if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
+  clang::TagDecl *origin_decl = llvm::cast<TagDecl>(decl_origin.decl);
+
+  origin_decl = origin_decl->getDefinition();
+  if (!origin_decl)
     return false;
 
   ImporterDelegateSP delegate_sp(
       GetDelegate(&decl->getASTContext(), decl_origin.ctx));
 
   ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp,
                                                 &decl->getASTContext());
-  if (delegate_sp)
-    delegate_sp->ImportDefinitionTo(decl, decl_origin.decl);
+  llvm::Expected<Decl *> result = delegate_sp->Import(origin_decl);
+  if (!result) {
+    llvm::handleAllErrors(result.takeError(), [](const clang::ImportError &e) {
+        llvm::errs() << "ERR: " << e.toString() << "\n";
+    });
+    return false;
+  }
+
+  TagDecl *result_decl = llvm::cast<TagDecl>(*result);
+  if (!decl->isThisDeclarationADefinition() && result_decl != decl) {
+    if (result_decl->getPreviousDecl() == nullptr) {
+      result_decl->setPreviousDecl(const_cast<TagDecl *>(decl));
+    }
+  }
 
   return true;
 }
 
-bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl,
+bool ClangASTImporter::CompleteTagDeclWithOrigin(const clang::TagDecl *decl,
                                                  clang::TagDecl *origin_decl) {
-  clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
-
-  if (!TypeSystemClang::GetCompleteDecl(origin_ast_ctx, origin_decl))
+  if (!origin_decl->getDefinition())
     return false;
+  origin_decl = origin_decl->getFirstDecl();
 
-  ImporterDelegateSP delegate_sp(
-      GetDelegate(&decl->getASTContext(), origin_ast_ctx));
-
-  if (delegate_sp)
-    delegate_sp->ImportDefinitionTo(decl, origin_decl);
-
+  clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
-
   context_md->setOrigin(decl, DeclOrigin(origin_ast_ctx, origin_decl));
-  return true;
+
+  return CompleteTagDecl(decl);
 }
 
-bool ClangASTImporter::CompleteObjCInterfaceDecl(
-    clang::ObjCInterfaceDecl *interface_decl) {
+bool ClangASTImporter::CompleteObjCInterfaceDecl(const ObjCInterfaceDecl *interface_decl) {
   DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
 
   if (!decl_origin.Valid())
     return false;
 
-  if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
-    return false;
-
-  ImporterDelegateSP delegate_sp(
-      GetDelegate(&interface_decl->getASTContext(), decl_origin.ctx));
-
-  if (delegate_sp)
-    delegate_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
-
-  if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
-    RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0));
-
-  return true;
-}
-
-bool ClangASTImporter::CompleteAndFetchChildren(clang::QualType type) {
-  if (!RequireCompleteType(type))
-    return false;
-
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
-
-  if (const TagType *tag_type = type->getAs<TagType>()) {
-    TagDecl *tag_decl = tag_type->getDecl();
-
-    DeclOrigin decl_origin = GetDeclOrigin(tag_decl);
+  ObjCInterfaceDecl *origin_decl = llvm::cast<ObjCInterfaceDecl>(decl_origin.decl);
 
-    if (!decl_origin.Valid())
-      return false;
+  origin_decl = origin_decl->getDefinition();
+  if (!origin_decl)
 
-    ImporterDelegateSP delegate_sp(
-        GetDelegate(&tag_decl->getASTContext(), decl_origin.ctx));
-
-    ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp,
-                                                  &tag_decl->getASTContext());
-
-    TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl);
-
-    for (Decl *origin_child_decl : origin_tag_decl->decls()) {
-      llvm::Expected<Decl *> imported_or_err =
-          delegate_sp->Import(origin_child_decl);
-      if (!imported_or_err) {
-        LLDB_LOG_ERROR(log, imported_or_err.takeError(),
-                       "Couldn't import decl: {0}");
-        return false;
-      }
-    }
-
-    if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl))
-      record_decl->setHasLoadedFieldsFromExternalStorage(true);
+      GetDelegate(&interface_decl->getASTContext(), decl_origin.ctx));
 
+  llvm::Expected<Decl *> result = delegate_sp->Import(origin_decl);
+  if (result)
     return true;
-  }
+  llvm::handleAllErrors(result.takeError(), [](clang::ImportError &e){
+      abort();
+  });
 
-  if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) {
-    if (ObjCInterfaceDecl *objc_interface_decl =
-            objc_object_type->getInterface()) {
-      DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl);
-
-      if (!decl_origin.Valid())
-        return false;
-
-      ImporterDelegateSP delegate_sp(
-          GetDelegate(&objc_interface_decl->getASTContext(), decl_origin.ctx));
-
-      ObjCInterfaceDecl *origin_interface_decl =
-          llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl);
-
-      for (Decl *origin_child_decl : origin_interface_decl->decls()) {
-        llvm::Expected<Decl *> imported_or_err =
-            delegate_sp->Import(origin_child_decl);
-        if (!imported_or_err) {
-          LLDB_LOG_ERROR(log, imported_or_err.takeError(),
-                         "Couldn't import decl: {0}");
-          return false;
-        }
-      }
 
-      return true;
-    }
-    return false;
-  }
-
-  return true;
+bool ClangASTImporter::CompleteAndFetchChildren(clang::QualType type) {
+  return RequireCompleteType(type);
 }
 
 bool ClangASTImporter::RequireCompleteType(clang::QualType type) {
   if (type.isNull())
     return false;
 
   if (const TagType *tag_type = type->getAs<TagType>()) {
     TagDecl *tag_decl = tag_type->getDecl();
ClangASTMetadata *ClangASTImporter::GetDeclMetadata(const clang::Decl *decl) {
   }
   TypeSystemClang *ast = TypeSystemClang::GetASTContext(&decl->getASTContext());
   return ast->GetMetadata(decl);
 }
 
 ClangASTImporter::DeclOrigin
 ClangASTImporter::GetDeclOrigin(const clang::Decl *decl) {
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
-
-  return context_md->getOrigin(decl);
+  DeclOrigin o = context_md->getOrigin(decl);
+  if (o.Valid())
+    return o;
+  return o;
 }
 
 void ClangASTImporter::SetDeclOrigin(const clang::Decl *decl,
                                      clang::Decl *original_decl) {
   ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
   context_md->setOrigin(
       decl, DeclOrigin(&original_decl->getASTContext(), original_decl));
 }
ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) {
   // Without this check we would ask the ASTImporter to import a declaration
   // into the same ASTContext where it came from (which doesn't make a lot of
   // sense).
   if (origin.Valid() && origin.ctx == &getToContext()) {
     RegisterImportedDecl(From, origin.decl);
     return origin.decl;
   }
 
-  // This declaration came originally from another ASTContext. Instead of
-  // copying our potentially incomplete 'From' Decl we instead go to the
-  // original ASTContext and copy the original to the target. This is not
-  // only faster than first completing our current decl and then copying it
-  // to the target, but it also prevents that indirectly copying the same
-  // declaration to the same target requires the ASTImporter to merge all
-  // the different decls that appear to come from different ASTContexts (even
-  // though all these different source ASTContexts just got a copy from
-  // one source AST).
-  if (origin.Valid()) {
-    auto R = m_master.CopyDecl(&getToContext(), origin.decl);
-    if (R) {
-      RegisterImportedDecl(From, R);
-      return R;
-    }
-  }
+  while(origin.Valid()) {
+    ImporterDelegateSP delegate = m_master.GetDelegate(&this->getToContext(), origin.ctx);
+    if (clang::Decl *imported = delegate->GetAlreadyImportedOrNull(origin.decl)) {
+      RegisterImportedDecl(From, imported);
+      return imported;
+    }
+    origin = m_master.GetDeclOrigin(origin.decl);
+  }
+
+  if (clang::TagDecl *td = dyn_cast<TagDecl>(From))
+    if (clang::ExternalASTSource *s = getToContext().getExternalSource())
+      if (!td->isThisDeclarationADefinition())
+        s->incrementGeneration(getToContext());
+
+  if (clang::ObjCInterfaceDecl *td = dyn_cast<ObjCInterfaceDecl>(From))
+    if (clang::ExternalASTSource *s = getToContext().getExternalSource())
+      if (!td->isThisDeclarationADefinition())
+        s->incrementGeneration(getToContext());
+
 
   // If we have a forcefully completed type, try to find an actual definition
   // for it in other modules.
   const ClangASTMetadata *md = m_master.GetDeclMetadata(From);
   auto *td = dyn_cast<TagDecl>(From);
   if (td && md && md->IsForcefullyCompleted()) {
     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
     LLDB_LOG(log,
              "[ClangASTImporter] Searching for a complete definition of {0} in "
              "other modules",
              td->getName());
     Expected<DeclContext *> dc_or_err = ImportContext(td->getDeclContext());
     if (!dc_or_err)
       return dc_or_err.takeError();
     Expected<DeclarationName> dn_or_err = Import(td->getDeclName());
     if (!dn_or_err)
       return dn_or_err.takeError();
     DeclContext *dc = *dc_or_err;
     DeclContext::lookup_result lr = dc->lookup(*dn_or_err);
     for (clang::Decl *candidate : lr) {
-      if (candidate->getKind() == From->getKind()) {
-        RegisterImportedDecl(From, candidate);
-        m_decls_to_ignore.insert(candidate);
-        return candidate;
-      }
-    }
+      clang::TagDecl *to_td = dyn_cast<TagDecl>(candidate);
+      if (!to_td)
+        continue;
+      if (!to_td->getDefinition())
+        continue;
     LLDB_LOG(log, "[ClangASTImporter] Complete definition not found");
   }
 
-  // Disable the minimal import for fields that have record types. There is
-  // no point in minimally importing the record behind their type as Clang
-  // will anyway request their definition when the FieldDecl is added to the
-  // RecordDecl (as Clang will query the FieldDecl's type for things such
-  // as a deleted constexpr destructor).
-  // By importing the type ahead of time we avoid some corner cases where
-  // the FieldDecl's record is importing in the middle of Clang's
-  // `DeclContext::addDecl` logic.
-  if (clang::FieldDecl *fd = dyn_cast<FieldDecl>(From)) {
-    // This is only necessary because we do the 'minimal import'. Remove this
-    // once LLDB stopped using that mode.
-    assert(isMinimalImport() && "Only necessary for minimal import");
-    QualType field_type = fd->getType();
-    if (field_type->isRecordType()) {
-      // First get the underlying record and minimally import it.
-      clang::TagDecl *record_decl = field_type->getAsTagDecl();
-      llvm::Expected<Decl *> imported = Import(record_decl);
-      if (!imported)
-        return imported.takeError();
-      // Check how/if the import got redirected to a different AST. Now
-      // import the definition of what was actually imported. If there is no
-      // origin then that means the record was imported by just picking a
-      // compatible type in the target AST (in which case there is no more
-      // importing to do).
-      if (clang::Decl *origin = m_master.GetDeclOrigin(*imported).decl) {
-        if (llvm::Error def_err = ImportDefinition(record_decl))
-          return std::move(def_err);
-      }
-    }
-  }
-
   return ASTImporter::ImportImpl(From);
 }
 
 void ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo(
     clang::Decl *to, clang::Decl *from) {
-  // We might have a forward declaration from a shared library that we
-  // gave external lexical storage so that Clang asks us about the full
-  // definition when it needs it. In this case the ASTImporter isn't aware
-  // that the forward decl from the shared library is the actual import
-  // target but would create a second declaration that would then be defined.
-  // We want that 'to' is actually complete after this function so let's
-  // tell the ASTImporter that 'to' was imported from 'from'.
-  MapImported(from, to);
-  ASTImporter::Imported(from, to);
-
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
-
-  if (llvm::Error err = ImportDefinition(from)) {
-    LLDB_LOG_ERROR(log, std::move(err),
-                   "[ClangASTImporter] Error during importing definition: {0}");
-    return;
-  }
-
-  if (clang::TagDecl *to_tag = dyn_cast<clang::TagDecl>(to)) {
-    if (clang::TagDecl *from_tag = dyn_cast<clang::TagDecl>(from)) {
-      to_tag->setCompleteDefinition(from_tag->isCompleteDefinition());
-
-      if (Log *log_ast =
-              lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_AST)) {
-        std::string name_string;
-        if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) {
-          llvm::raw_string_ostream name_stream(name_string);
-          from_named_decl->printName(name_stream);
-          name_stream.flush();
-        }
-        LLDB_LOG(log_ast, "==== [ClangASTImporter][TUDecl: {0}] Imported "
-                          "({1}Decl*){2}, named {3} (from "
-                          "(Decl*){4})",
-                 static_cast<void *>(to->getTranslationUnitDecl()),
-                 from->getDeclKindName(), static_cast<void *>(to), name_string,
-                 static_cast<void *>(from));
-
-        // Log the AST of the TU.
-        std::string ast_string;
-        llvm::raw_string_ostream ast_stream(ast_string);
-        to->getTranslationUnitDecl()->dump(ast_stream);
-        LLDB_LOG(log_ast, "{0}", ast_string);
-      }
-    }
-  }
-
   // If we're dealing with an Objective-C class, ensure that the inheritance
   // has been set up correctly.  The ASTImporter may not do this correctly if
   // the class was originally sourced from symbols.
 
   if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to)) {
     do {
       ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass();
 
do {
 
       if (!from_superclass)
         break;
 
       llvm::Expected<Decl *> imported_from_superclass_decl =
           Import(from_superclass);
 
       if (!imported_from_superclass_decl) {
-        LLDB_LOG_ERROR(log, imported_from_superclass_decl.takeError(),
-                       "Couldn't import decl: {0}");
         break;
       }
 
       ObjCInterfaceDecl *imported_from_superclass =
           dyn_cast<ObjCInterfaceDecl>(*imported_from_superclass_decl);
 
       if (!imported_from_superclass)
         break;
 
       if (!to_objc_interface->hasDefinition())
         to_objc_interface->startDefinition();
 
       to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo(
           m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
     } while (false);
   }
 }
 
-/// Takes a CXXMethodDecl and completes the return type if necessary. This
-/// is currently only necessary for virtual functions with covariant return
-/// types where Clang's CodeGen expects that the underlying records are already
-/// completed.
-static void MaybeCompleteReturnType(ClangASTImporter &importer,
-                                        CXXMethodDecl *to_method) {
-  if (!to_method->isVirtual())
-    return;
-  QualType return_type = to_method->getReturnType();
-  if (!return_type->isPointerType() && !return_type->isReferenceType())
-    return;
-
-  clang::RecordDecl *rd = return_type->getPointeeType()->getAsRecordDecl();
-  if (!rd)
-    return;
-  if (rd->getDefinition())
-    return;
-
-  importer.CompleteTagDecl(rd);
-}
-
 /// Recreate a module with its parents in \p to_source and return its id.
 static OptionalClangModuleID
 RemapModule(OptionalClangModuleID from_id,
             ClangExternalASTSourceCallbacks &from_source,
             ClangExternalASTSourceCallbacks &to_source) {
   if (!from_id.HasValue())
     return {};
   clang::Module *module = from_source.getModule(from_id.GetValue());
if (from_context_md) {
     if (origin.Valid()) {
       if (origin.ctx != &to->getASTContext()) {
         if (!to_context_md->hasOrigin(to) || user_id != LLDB_INVALID_UID)
           to_context_md->setOrigin(to, origin);
 
         ImporterDelegateSP direct_completer =
             m_master.GetDelegate(&to->getASTContext(), origin.ctx);
 
-        if (direct_completer.get() != this)
-          direct_completer->ASTImporter::Imported(origin.decl, to);
+        if (direct_completer.get() != this && !direct_completer->GetAlreadyImportedOrNull(origin.decl) && !direct_completer->getImportedFromDecl(to)) {
+          direct_completer->MapImported(origin.decl, to);
+        }
 
         LLDB_LOG(log,
                  "    [ClangASTImporter] Propagated origin "
                  "(Decl*){0}/(ASTContext*){1} from (ASTContext*){2} to "
                  "(ASTContext*){3}",
                  origin.decl, origin.ctx, &from->getASTContext(),
                  &to->getASTContext());
       }
if (from_context_md) {
     to_context_md->setOrigin(to, DeclOrigin(m_source_ctx, from));
 
     LLDB_LOG(log,
              "    [ClangASTImporter] Sourced origin "
              "(Decl*){0}/(ASTContext*){1} into (ASTContext*){2}",
              from, m_source_ctx, &to->getASTContext());
   }
 
-  if (auto *to_tag_decl = dyn_cast<TagDecl>(to)) {
-    to_tag_decl->setHasExternalLexicalStorage();
-    to_tag_decl->getPrimaryContext()->setMustBuildLookupTable();
-    auto from_tag_decl = cast<TagDecl>(from);
-
-    LLDB_LOG(
-        log,
-        "    [ClangASTImporter] To is a TagDecl - attributes {0}{1} [{2}->{3}]",
-        (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
-        (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
-        (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
-        (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
-  }
-
   if (auto *to_namespace_decl = dyn_cast<NamespaceDecl>(to)) {
     m_master.BuildNamespaceMap(to_namespace_decl);
     to_namespace_decl->setHasExternalVisibleStorage();
   }
 
   if (auto *to_container_decl = dyn_cast<ObjCContainerDecl>(to)) {
-    to_container_decl->setHasExternalLexicalStorage();
-    to_container_decl->setHasExternalVisibleStorage();
-
     if (log) {
       if (ObjCInterfaceDecl *to_interface_decl =
               llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl)) {
         LLDB_LOG(
             log,
             "    [ClangASTImporter] To is an ObjCInterfaceDecl - attributes "
-            "{0}{1}{2}",
-            (to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
-            (to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""),
+            "{0}",
             (to_interface_decl->hasDefinition() ? " HasDefinition" : ""));
       } else {
         LLDB_LOG(
-            log, "    [ClangASTImporter] To is an {0}Decl - attributes {1}{2}",
-            ((Decl *)to_container_decl)->getDeclKindName(),
-            (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
-            (to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
+            log, "    [ClangASTImporter] To is an {0}Decl",
+            ((Decl *)to_container_decl)->getDeclKindName());
       }
     }
   }
 
-  if (clang::CXXMethodDecl *to_method = dyn_cast<CXXMethodDecl>(to))
-    MaybeCompleteReturnType(m_master, to_method);
+  if (clang::ObjCInterfaceDecl *td = dyn_cast<ObjCInterfaceDecl>(to)) {
+    if (clang::ExternalASTSource *s = getToContext().getExternalSource())
+      if (td->isThisDeclarationADefinition())
+        s->CompleteRedeclChain(td);
+    td->setHasExternalVisibleStorage();
+  }
 }
 
 clang::Decl *
 ClangASTImporter::ASTImporterDelegate::GetOriginalDecl(clang::Decl *To) {
   return m_master.GetDeclOrigin(To).decl;
 }

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

public:
   void CompleteType(clang::TagDecl *Tag) override;
 
   /// Complete an ObjCInterfaceDecl.
   ///
   /// \param[in] Class
   ///     The Decl to be completed in place.
   void CompleteType(clang::ObjCInterfaceDecl *Class) override;
 
+  void CompleteRedeclChain(const clang::Decl *D) override;
+
   /// Called on entering a translation unit.  Tells Clang by calling
   /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage() that
   /// this object has something to say about undefined names.
   ///
   /// \param[in] Consumer
   ///     Unused.
   void StartTranslationUnit(clang::ASTConsumer *Consumer) override;
 
public:
     void CompleteType(clang::TagDecl *Tag) override {
       return m_original.CompleteType(Tag);
     }
 
     void CompleteType(clang::ObjCInterfaceDecl *Class) override {
       return m_original.CompleteType(Class);
     }
 
+    void CompleteRedeclChain(const clang::Decl *D) override {
+      return m_original.CompleteRedeclChain(D);
+    }
+
+
     bool layoutRecordType(
         const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
         llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
             &BaseOffsets,
         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
             &VirtualBaseOffsets) override {
       return m_original.layoutRecordType(Record, Size, Alignment, FieldOffsets,

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

void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
   if (interface_decl->getSuperClass() &&
       interface_decl->getSuperClass() != interface_decl)
     CompleteType(interface_decl->getSuperClass());
 
   LLDB_LOG(log, "      [COID] After:");
   LLDB_LOG(log, "      [COID] {0}", ClangUtil::DumpDecl(interface_decl));
 }
 
+void ClangASTSource::CompleteRedeclChain(const Decl *d) {
+  if (const clang::TagDecl *td = llvm::dyn_cast<TagDecl>(d)) {
+    if (td->isBeingDefined())
+      return;
+    if (td->getDefinition())
+      return;
+    m_ast_importer_sp->CompleteTagDecl(td);
+    if (!td->getDefinition() && m_ast_importer_sp->GetDeclOrigin(td).Valid()) {
+      if (TagDecl *alternate = FindCompleteType(td))
+        m_ast_importer_sp->CompleteTagDeclWithOrigin(td, alternate);
+    }
+  }
+  if (const auto *od = llvm::dyn_cast<ObjCInterfaceDecl>(d)) {
+    ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(od);
+    if (ObjCInterfaceDecl *orig = dyn_cast_or_null<ObjCInterfaceDecl>(original.decl)) {
+      if (ObjCInterfaceDecl *i = GetCompleteObjCInterface(orig)) {
+        if (i != orig) {
+          m_ast_importer_sp->SetDeclOrigin(d, i);
+          m_ast_importer_sp->CompleteObjCInterfaceDecl(od);
+          return;
+        }
+      }
+    }
+    if (od->getDefinition())
+      return;
+    m_ast_importer_sp->CompleteObjCInterfaceDecl(od);
+  }
+}
+
 clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
     const clang::ObjCInterfaceDecl *interface_decl) {
   lldb::ProcessSP process(m_target->GetProcessSP());
 
   if (!process)
     return nullptr;
 
   ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
   const ObjCInterfaceType *complete_interface_type =
       dyn_cast<ObjCInterfaceType>(complete_clang_type);
 
   if (!complete_interface_type)
     return nullptr;
 
   ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl());
 
-  return complete_iface_decl;
+  ObjCInterfaceDecl *def = complete_iface_decl->getDefinition();
+  return def;
 }
 
 void ClangASTSource::FindExternalLexicalDecls(
     const DeclContext *decl_context,
     llvm::function_ref<bool(Decl::Kind)> predicate,
     llvm::SmallVectorImpl<Decl *> &decls) {
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
   if (!definition || !definition->isCompleteDefinition())
     return false;
 
   const ASTRecordLayout &record_layout(
       origin_record->getASTContext().getASTRecordLayout(origin_record.decl));
 
   int field_idx = 0, field_count = record_layout.getFieldCount();
 
-  for (RecordDecl::field_iterator fi = origin_record->field_begin(),
-                                  fe = origin_record->field_end();
+  for (RecordDecl::field_iterator fi = definition->field_begin(),
+                                  fe = definition->field_end();
        fi != fe; ++fi) {
     if (field_idx >= field_count)
       return false; // Layout didn't go well.  Bail out.
 
     uint64_t field_offset = record_layout.getFieldOffset(field_idx);
 
     origin_field_offsets.insert(
         std::pair<const FieldDecl *, uint64_t>(*fi, field_offset));

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

ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager,
   }
 
   {
     llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(
         &m_compiler->getSema());
     ParseAST(m_compiler->getSema(), false, false);
   }
 
-  // Make sure we have no pointer to the Sema we are about to destroy.
-  if (ast_context.getLangOpts().Modules)
-    m_ast_context->setSema(nullptr);
-  // Destroy the Sema. This is necessary because we want to emulate the
-  // original behavior of ParseAST (which also destroys the Sema after parsing).
-  m_compiler->setSema(nullptr);
-
   adapter->EndSourceFile();
 
   unsigned num_errors = adapter->getNumErrors();
 
   if (m_pp_callbacks && m_pp_callbacks->hasErrors()) {
     num_errors++;
     diagnostic_manager.PutString(eDiagnosticSeverityError,
                                  "while importing modules:");
if (decl_map) {
     if (execution_policy == eExecutionPolicyAlways ||
         execution_policy == eExecutionPolicyTopLevel || !can_interpret) {
       execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
     }
   } else {
     execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
   }
 
+  // Make sure we have no pointer to the Sema we are about to destroy.
+  if (m_ast_context->getASTContext().getLangOpts().Modules)
+    m_ast_context->setSema(nullptr);
+  // Destroy the Sema. This is necessary because we want to emulate the
+  // original behavior of ParseAST (which also destroys the Sema after parsing).
+  m_compiler->setSema(nullptr);
+
   return err;
 }
 
 lldb_private::Status ClangExpressionParser::RunStaticInitializers(
     lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx) {
   lldb_private::Status err;
 
   lldbassert(execution_unit_sp.get());

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

public:
 
   bool FindExternalVisibleDeclsByName(const clang::DeclContext *DC,
                                       clang::DeclarationName Name) override;
 
   void CompleteType(clang::TagDecl *tag_decl) override;
 
   void CompleteType(clang::ObjCInterfaceDecl *objc_decl) override;
 
+  void CompleteRedeclChain(const clang::Decl *D) override;
+
   bool layoutRecordType(
       const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &BaseOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &VirtualBaseOffsets) override;
 
   TypeSystemClang &GetTypeSystem() const { return m_ast; }
 
+  void bumpGeneration() {
+    incrementGeneration(m_ast.getASTContext());
+  }
+
   /// Module-related methods.
   /// \{
   llvm::Optional<clang::ASTSourceDescriptor>
   getSourceDescriptor(unsigned ID) override;
   clang::Module *getModule(unsigned ID) override;
   OptionalClangModuleID RegisterModule(clang::Module *module);
   OptionalClangModuleID GetIDForModule(clang::Module *module);
   /// \}

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

 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 
 using namespace lldb_private;
 
 char ClangExternalASTSourceCallbacks::ID;
 
 void ClangExternalASTSourceCallbacks::CompleteType(clang::TagDecl *tag_decl) {
-  m_ast.CompleteTagDecl(tag_decl);
+  //m_ast.CompleteTagDecl(tag_decl);
 }
 
 void ClangExternalASTSourceCallbacks::CompleteType(
     clang::ObjCInterfaceDecl *objc_decl) {
   m_ast.CompleteObjCInterfaceDecl(objc_decl);
 }
 
+void ClangExternalASTSourceCallbacks::CompleteRedeclChain(const clang::Decl *d) {
+  if (const clang::TagDecl *td = llvm::dyn_cast<clang::TagDecl>(d)) {
+    if (td->isBeingDefined())
+      return;
+    if (td->getDefinition())
+      return;
+    m_ast.CompleteTagDecl(td);
+  }
+  if (const auto *od = llvm::dyn_cast<clang::ObjCInterfaceDecl>(d)) {
+    if (od->getDefinition())
+      return;
+    m_ast.CompleteObjCInterfaceDecl(od);
+  }
+}
+
 bool ClangExternalASTSourceCallbacks::layoutRecordType(
     const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &BaseOffsets,
     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
         &VirtualBaseOffsets) {
   return m_ast.LayoutRecordType(Record, Size, Alignment, FieldOffsets,
                                 BaseOffsets, VirtualBaseOffsets);

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);
 
+  static clang::ObjCInterfaceDecl *GetAsObjCDecl(const CompilerType &type);
+
+  static clang::Decl *GetFirstDecl(clang::Decl *d);
+
+  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 "clang/AST/DeclObjC.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 
 using namespace clang;
 using namespace lldb_private;
 
 bool ClangUtil::IsClangType(const CompilerType &ct) {
   // Invalid types are never Clang types.
CompilerType ClangUtil::RemoveFastQualifiers(const CompilerType &ct) {
   return CompilerType(ct.GetTypeSystem(), qual_type.getAsOpaquePtr());
 }
 
 clang::TagDecl *ClangUtil::GetAsTagDecl(const CompilerType &type) {
   clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
   if (qual_type.isNull())
     return nullptr;
 
+  if (const TagType *tt = llvm::dyn_cast<TagType>(qual_type.getTypePtr()))
+    return tt->getCanonicalDecl();
+
   return qual_type->getAsTagDecl();
 }
 
+clang::ObjCInterfaceDecl *ClangUtil::GetAsObjCDecl(const CompilerType &type) {
+  clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
+  if (qual_type.isNull())
+    return nullptr;
+
+  if (const auto *ot = qual_type->getAsObjCInterfaceType())
+    return ot->getInterface();
+  if (const auto *ot = qual_type->getAsObjCInterfacePointerType())
+    return ot->getInterfaceDecl();
+  return nullptr;
+}
+
+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/ExpressionParser/Clang/CxxModuleHandler.cpp

static void makeScopes(Sema &sema, DeclContext *ctxt,
 
   if (auto parent = ctxt->getParent()) {
     makeScopes(sema, parent, result);
 
     Scope *scope =
         new Scope(result.back(), Scope::DeclScope, sema.getDiagnostics());
     scope->setEntity(ctxt);
     result.push_back(scope);
-  } else
+  } else {
+    assert(sema.TUScope != nullptr);
     result.push_back(sema.TUScope);
   }
+}
 
 /// Uses the Sema to look up the given name in the given DeclContext.
 static std::unique_ptr<LookupResult>
 emulateLookupInCtxt(Sema &sema, llvm::StringRef name, DeclContext *ctxt) {
   IdentifierInfo &ident = sema.getASTContext().Idents.get(name);
 
   std::unique_ptr<LookupResult> lookup_result;
   lookup_result = std::make_unique<LookupResult>(sema, DeclarationName(&ident),
llvm::Optional<Decl *> CxxModuleHandler::tryInstantiateStdTemplate(Decl *d) {
 
   // Find the class template specialization declaration that
   // corresponds to these arguments.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *result =
       new_class_template->findSpecialization(imported_args, InsertPos);
 
   if (result) {
+    // Don't substitute a definition with a declaration.
+    if (td->isThisDeclarationADefinition() && !result->getDefinition())
+      return llvm::None;
     // We found an existing specialization in the module that fits our arguments
     // so we can treat it as the result and register it with the ASTImporter.
     m_importer->RegisterImportedDecl(d, result);
     return result;
   }
 
   // Instantiate the template.
   result = createDecl<ClassTemplateSpecializationDecl>(

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

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+#include "llvm/IR/LegacyPassManager.h"
 
 #include "clang/AST/ASTContext.h"
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/ConstString.h"

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

private:
   ObjCLanguageRuntime::EncodingToTypeSP m_type_realizer_sp;
   AppleObjCExternalASTSource *m_external_source;
 
   typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA,
                          clang::ObjCInterfaceDecl *>
       ISAToInterfaceMap;
 
   ISAToInterfaceMap m_isa_to_interface;
+
+  typedef llvm::DenseMap<clang::ObjCInterfaceDecl *,
+                         ObjCLanguageRuntime::ObjCISA>
+      InterfaceToISAMap;
+  InterfaceToISAMap m_interface_to_isa;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCDECLVENDOR_H

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

 using namespace lldb_private;
 
 class lldb_private::AppleObjCExternalASTSource
     : public clang::ExternalASTSource {
 public:
   AppleObjCExternalASTSource(AppleObjCDeclVendor &decl_vendor)
       : m_decl_vendor(decl_vendor) {}
 
-  bool FindExternalVisibleDeclsByName(const clang::DeclContext *decl_ctx,
-                                      clang::DeclarationName name) override {
-
-    Log *log(GetLogIfAllCategoriesSet(
-        LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
-
-    if (log) {
-      LLDB_LOGF(log,
-                "AppleObjCExternalASTSource::FindExternalVisibleDeclsByName"
-                " on (ASTContext*)%p Looking for %s in (%sDecl*)%p",
-                static_cast<void *>(&decl_ctx->getParentASTContext()),
-                name.getAsString().c_str(), decl_ctx->getDeclKindName(),
-                static_cast<const void *>(decl_ctx));
-    }
-
-    do {
-      const clang::ObjCInterfaceDecl *interface_decl =
-          llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
-
-      if (!interface_decl)
-        break;
-
-      clang::ObjCInterfaceDecl *non_const_interface_decl =
-          const_cast<clang::ObjCInterfaceDecl *>(interface_decl);
-
-      if (!m_decl_vendor.FinishDecl(non_const_interface_decl))
-        break;
-
-      clang::DeclContext::lookup_result result =
-          non_const_interface_decl->lookup(name);
-
-      return (!result.empty());
-    } while (false);
-
-    SetNoExternalVisibleDeclsForName(decl_ctx, name);
-    return false;
-  }
-
-  void CompleteType(clang::TagDecl *tag_decl) override {
-
-    Log *log(GetLogIfAllCategoriesSet(
-        LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
-
-    LLDB_LOGF(log,
-              "AppleObjCExternalASTSource::CompleteType on "
-              "(ASTContext*)%p Completing (TagDecl*)%p named %s",
-              static_cast<void *>(&tag_decl->getASTContext()),
-              static_cast<void *>(tag_decl), tag_decl->getName().str().c_str());
-
-    LLDB_LOG(log, "  AOEAS::CT Before:\n{1}", ClangUtil::DumpDecl(tag_decl));
-
-    LLDB_LOG(log, "  AOEAS::CT After:{1}", ClangUtil::DumpDecl(tag_decl));
-
-    return;
-  }
-
-  void CompleteType(clang::ObjCInterfaceDecl *interface_decl) override {
-
-    Log *log(GetLogIfAllCategoriesSet(
-        LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
-
-    if (log) {
-      LLDB_LOGF(log,
-                "AppleObjCExternalASTSource::CompleteType on "
-                "(ASTContext*)%p Completing (ObjCInterfaceDecl*)%p named %s",
-                static_cast<void *>(&interface_decl->getASTContext()),
-                static_cast<void *>(interface_decl),
-                interface_decl->getName().str().c_str());
-
-      LLDB_LOGF(log, "  AOEAS::CT Before:");
-      LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
-    }
-
-    m_decl_vendor.FinishDecl(interface_decl);
-
-    if (log) {
-      LLDB_LOGF(log, "  [CT] After:");
-      LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
-    }
+  void CompleteRedeclChain(const clang::Decl *d) override {
+    using namespace clang;
+    auto *const_interface = llvm::dyn_cast<ObjCInterfaceDecl>(d);
+    if (!const_interface)
       return;
+    auto *interface = const_cast<ObjCInterfaceDecl *>(const_interface);
+    m_decl_vendor.FinishDecl(interface);
   }
 
   bool layoutRecordType(
       const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
           &BaseOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
AppleObjCDeclVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa) {
   clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create(
       ast_ctx, ast_ctx.getTranslationUnitDecl(), clang::SourceLocation(),
       &identifier_info, nullptr, nullptr);
 
   ClangASTMetadata meta_data;
   meta_data.SetISAPtr(isa);
   m_ast_ctx.SetMetadata(new_iface_decl, meta_data);
 
-  new_iface_decl->setHasExternalVisibleStorage();
-  new_iface_decl->setHasExternalLexicalStorage();
-
   ast_ctx.getTranslationUnitDecl()->addDecl(new_iface_decl);
 
   m_isa_to_interface[isa] = new_iface_decl;
+  m_interface_to_isa[new_iface_decl] = isa;
+  m_ast_ctx.BumpGenerationCounter();
 
   return new_iface_decl;
 }
 
 class ObjCRuntimeMethodType {
 public:
   ObjCRuntimeMethodType(const char *types) : m_is_valid(false) {
     const char *cursor = types;

 
 private:
   typedef std::vector<std::string> TypeVector;
 
   TypeVector m_type_vector;
   bool m_is_valid;
 };
 
-bool AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl) {
+bool AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *fwd_decl) {
+  if (fwd_decl->hasDefinition())
+    return true;
   Log *log(GetLogIfAllCategoriesSet(
       LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
+  using namespace clang;
+
+  QualType qt(fwd_decl->getTypeForDecl(), 0U);
+  CompilerType type(&m_ast_ctx, qt.getAsOpaquePtr());
+  CompilerType definition_type = m_ast_ctx.RedeclTagDecl(type);
+  ObjCInterfaceDecl *interface_decl = ClangUtil::GetAsObjCDecl(definition_type);
+
+  ObjCLanguageRuntime::ObjCISA isa = m_interface_to_isa[fwd_decl];
+  m_isa_to_interface[isa] = interface_decl;
 
-  ClangASTMetadata *metadata = m_ast_ctx.GetMetadata(interface_decl);
+  ClangASTMetadata *metadata = m_ast_ctx.GetMetadata(fwd_decl);
   ObjCLanguageRuntime::ObjCISA objc_isa = 0;
   if (metadata)
     objc_isa = metadata->GetISAPtr();
 
   if (!objc_isa)
     return false;
 
-  if (!interface_decl->hasExternalVisibleStorage())
-    return true;
-
   interface_decl->startDefinition();
 
-  interface_decl->setHasExternalVisibleStorage(false);
-  interface_decl->setHasExternalLexicalStorage(false);
-
   ObjCLanguageRuntime::ClassDescriptorSP descriptor =
       m_runtime.GetClassDescriptorFromISA(objc_isa);
 
   if (!descriptor)
     return false;
 
   auto superclass_func = [interface_decl,
                           this](ObjCLanguageRuntime::ObjCISA isa) {

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

 protected:
   /// Protected typedefs and members.
   /// @{
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
       DIEToDeclContextMap;
+  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::TagDecl *>
+      DIEToRecordMap;
+  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::ObjCInterfaceDecl *>
+      DIEToObjCInterfaceMap;
   typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
       DeclContextToDIEMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb_private::OptionalClangModuleID>
       DIEToModuleMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
       DIEToDeclMap;
 
   lldb_private::TypeSystemClang &m_ast;
   DIEToDeclMap m_die_to_decl;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
+  DIEToRecordMap m_die_to_record_map;
+  DIEToObjCInterfaceMap m_die_to_objc_interface_map;
   DIEToModuleMap m_die_to_module;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
+
+  struct TypeToComplete {
+    lldb_private::CompilerType clang_type;
+    DWARFDIE die;
+    lldb::TypeSP type;
+  };
+  std::vector<TypeToComplete> m_to_complete;
+  llvm::DenseSet<const DWARFDebugInfoEntry *> m_currently_parsed_record_dies;
+
   /// @}
 
+  void RegisterDIE(DWARFDebugInfoEntry *die, lldb_private::CompilerType type);
+
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
 
   clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
 
   clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
 
   bool ParseTemplateDIE(const DWARFDIE &die,
                         lldb_private::TypeSystemClang::TemplateParameterInfos
private:
   void
   ParseSingleMember(const DWARFDIE &die, const DWARFDIE &parent_die,
                     const lldb_private::CompilerType &class_clang_type,
                     lldb::AccessType default_accessibility,
                     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
                     FieldInfo &last_field_info);
 
   bool CompleteRecordType(const DWARFDIE &die, lldb_private::Type *type,
-                          lldb_private::CompilerType &clang_type);
+                          lldb_private::CompilerType clang_type);
   bool CompleteEnumType(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &clang_type);
 
   lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc,
                                  const DWARFDIE &die,
                                  ParsedDWARFTypeAttributes &attrs);
   lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, ParsedDWARFTypeAttributes &attrs);

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

 #include <cstdio>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
+
+namespace {
+struct GenerationBumper {
+  TypeSystemClang &m_ts;
+  bool engaged = true;
+  explicit GenerationBumper(TypeSystemClang &ts) : m_ts(ts) {
+  }
+  ~GenerationBumper() {
+    if (engaged)
+      m_ts.BumpGenerationCounter();
+  }
+  void engage() {
+    engaged = true;
+  }
+};
+}
+
+static bool DirectlyCompleteType(clang::DeclContext *decl_ctx, const ParsedDWARFTypeAttributes &attrs) {
+  assert(decl_ctx);
+  if (decl_ctx->isFunctionOrMethod())
+    return true;
+  return attrs.name.IsEmpty() && !attrs.is_forward_declaration;
+}
+
 DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
     : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
 
 DWARFASTParserClang::~DWARFASTParserClang() = default;
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:

 
 ClangASTImporter &DWARFASTParserClang::GetClangASTImporter() {
   if (!m_clang_ast_importer_up) {
     m_clang_ast_importer_up = std::make_unique<ClangASTImporter>();
   }
   return *m_clang_ast_importer_up;
 }
 
+void DWARFASTParserClang::RegisterDIE(DWARFDebugInfoEntry *die,
+                                      CompilerType type) {
+  if (clang::TagDecl *td = ClangUtil::GetAsTagDecl(type)) {
+    m_die_to_record_map[die] = td;
+  } else if (auto *od = ClangUtil::GetAsObjCDecl(type))
+    m_die_to_objc_interface_map[die] = od;
+  else {
+    assert(false && "Unknown Decl kind?");
+  }
+}
+
 /// Detect a forward declaration that is nested in a DW_TAG_module.
 static bool IsClangModuleFwdDecl(const DWARFDIE &Die) {
   if (!Die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0))
     return false;
   auto Parent = Die.GetParent();
   while (Parent.IsValid()) {
     if (Parent.Tag() == DW_TAG_module)
       return true;
static void RequireCompleteType(CompilerType type) {
   // Since we provide layout assistance, layouts of types containing this class
   // will be correct even if we  are not able to find the definition elsewhere.
   ForcefullyCompleteType(type);
 }
 
 /// This function serves a similar purpose as RequireCompleteType above, but it
 /// avoids completing the type if it is not immediately necessary. It only
 /// ensures we _can_ complete the type later.
+/// FIXME: Not true anymore, will now pull in definition.
 static void PrepareContextToReceiveMembers(TypeSystemClang &ast,
                                            ClangASTImporter &ast_importer,
                                            clang::DeclContext *decl_ctx,
                                            DWARFDIE die,
                                            const char *type_name_cstr) {
   auto *tag_decl_ctx = clang::dyn_cast<clang::TagDecl>(decl_ctx);
   if (!tag_decl_ctx)
     return; // Non-tag context are always ready.
 
   // We have already completed the type, or we have found its definition and are
   // ready to complete it later (cf. ParseStructureLikeDIE).
-  if (tag_decl_ctx->isCompleteDefinition() || tag_decl_ctx->isBeingDefined())
+  if (tag_decl_ctx->getDefinition() || tag_decl_ctx->isBeingDefined())
     return;
 
   // We reach this point of the tag was present in the debug info as a
   // declaration only. If it was imported from another AST context (in the
   // gmodules case), we can complete the type by doing a full import.
 
   // If this type was not imported from an external AST, there's nothing to do.
+  if (ast_importer.CanImport(tag_decl_ctx)) {
     CompilerType type = ast.GetTypeForDecl(tag_decl_ctx);
-  if (type && ast_importer.CanImport(type)) {
     auto qual_type = ClangUtil::GetQualType(type);
     if (ast_importer.RequireCompleteType(qual_type))
       return;
     die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
         "Unable to complete the Decl context for DIE '%s' at offset "
         "0x%8.8x.\nPlease file a bug report.",
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
   }
 
   // We don't have a type definition and/or the import failed. We must
   // forcefully complete the type to avoid crashes.
-  ForcefullyCompleteType(type);
+  ForcefullyCompleteType(ast.GetTypeForDecl(tag_decl_ctx));
 }
 
 ParsedDWARFTypeAttributes::ParsedDWARFTypeAttributes(const DWARFDIE &die) {
   DWARFAttributes attributes;
   size_t num_attributes = die.GetAttributes(attributes);
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
     DWARFFormValue form_value;
dwarf->GetObjectFile()->GetModule()->LogMessage(
         log,
         "DWARFASTParserClang::ParseTypeFromDWARF "
         "(die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
         die.GetOffset(), static_cast<void *>(context), context_die.GetOffset(),
         die.GetTagAsCString(), die.GetName());
   }
 
   Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
-  if (type_ptr == DIE_IS_BEING_PARSED)
-    return nullptr;
   if (type_ptr)
     return type_ptr->shared_from_this();
-  // Set a bit that lets us know that we are currently parsing this
-  dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
   ParsedDWARFTypeAttributes attrs(die);
 
   if (DWARFDIE signature_die = attrs.signature.Reference()) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr)) {
       dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
dwarf->GetObjectFile()->GetModule()->ReportError(
         "attach the file at the start of this error message",
         die.GetOffset(), tag, DW_TAG_value_to_name(tag));
     break;
   }
 
   // TODO: We should consider making the switch above exhaustive to simplify
   // control flow in ParseTypeFromDWARF. Then, we could simply replace this
   // return statement with a call to llvm_unreachable.
-  return UpdateSymbolContextScopeForType(sc, die, type_sp);
+  lldb::TypeSP t = UpdateSymbolContextScopeForType(sc, die, type_sp);
+
+  while (!m_to_complete.empty()) {
+    TypeToComplete to_complete = m_to_complete.back();
+    m_to_complete.pop_back();
+    CompleteRecordType(to_complete.die, to_complete.type.get(), to_complete.clang_type);
+  }
+
+  return t;
 }
 
 lldb::TypeSP
 DWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc,
                                        const DWARFDIE &die,
                                        ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
if (type_sp) {
       return type_sp;
     }
   }
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
   CompilerType enumerator_clang_type;
   CompilerType clang_type;
+
   clang_type.SetCompilerType(
       &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
   if (!clang_type) {
     if (attrs.type.IsValid()) {
       Type *enumerator_type =
           dwarf->ResolveTypeUID(attrs.type.Reference(), true);
       if (enumerator_type)
         enumerator_clang_type = enumerator_type->GetFullCompilerType();
TypeSP DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die,
   // Parse the function children for the parameters
 
   DWARFDIE decl_ctx_die;
   clang::DeclContext *containing_decl_ctx =
       GetClangDeclContextContainingDIE(die, &decl_ctx_die);
   const clang::Decl::Kind containing_decl_kind =
       containing_decl_ctx->getDeclKind();
 
+  PrepareContextToReceiveMembers(m_ast, GetClangASTImporter(), containing_decl_ctx, die,
+                                 attrs.name.GetCString());
+
   bool is_cxx_method = DeclKindIsCXXClass(containing_decl_kind);
   // Start off static. This will be set to false in
   // ParseChildParameters(...) if we find a "this" parameters as the
   // first parameter
   if (is_cxx_method) {
     is_static = true;
   }
 
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                   ") has no decl\n",
                   die.GetID(), abs_die.GetOffset());
             }
             type_handled = true;
           } else {
             CompilerType class_opaque_type =
                 class_type->GetForwardCompilerType();
             if (TypeSystemClang::IsCXXClassType(class_opaque_type)) {
-              if (class_opaque_type.IsBeingDefined() || alternate_defn) {
-                if (!is_static && !die.HasChildren()) {
-                  // We have a C++ member function with no children (this
-                  // pointer!) and clang will get mad if we try and make
-                  // a function that isn't well formed in the DWARF, so
-                  // we will just skip it...
-                  type_handled = true;
-                } else {
-                  bool add_method = true;
-                  if (alternate_defn) {
-                    // If an alternate definition for the class exists,
-                    // then add the method only if an equivalent is not
-                    // already present.
-                    clang::CXXRecordDecl *record_decl =
-                        m_ast.GetAsCXXRecordDecl(
-                            class_opaque_type.GetOpaqueQualType());
-                    if (record_decl) {
-                      for (auto method_iter = record_decl->method_begin();
-                           method_iter != record_decl->method_end();
-                           method_iter++) {
-                        clang::CXXMethodDecl *method_decl = *method_iter;
-                        if (method_decl->getNameInfo().getAsString() ==
-                            attrs.name.GetStringRef()) {
-                          if (method_decl->getType() ==
-                              ClangUtil::GetQualType(clang_type)) {
-                            add_method = false;
-                            LinkDeclContextToDIE(method_decl, die);
-                            type_handled = true;
 
-                            break;
-                          }
-                        }
-                      }
-                    }
-                  }
 
-                  if (add_method) {
-                    llvm::PrettyStackTraceFormat stack_trace(
-                        "SymbolFileDWARF::ParseType() is adding a method "
-                        "%s to class %s in DIE 0x%8.8" PRIx64 " from %s",
-                        attrs.name.GetCString(),
-                        class_type->GetName().GetCString(), die.GetID(),
-                        dwarf->GetObjectFile()
-                            ->GetFileSpec()
-                            .GetPath()
-                            .c_str());
 
-                    const bool is_attr_used = false;
-                    // Neither GCC 4.2 nor clang++ currently set a valid
-                    // accessibility in the DWARF for C++ methods...
-                    // Default to public for now...
-                    if (attrs.accessibility == eAccessNone)
-                      attrs.accessibility = eAccessPublic;
 
-                    clang::CXXMethodDecl *cxx_method_decl =
-                        m_ast.AddMethodToCXXRecordType(
-                            class_opaque_type.GetOpaqueQualType(),
-                            attrs.name.GetCString(), attrs.mangled_name,
-                            clang_type, attrs.accessibility, attrs.is_virtual,
-                            is_static, attrs.is_inline, attrs.is_explicit,
-                            is_attr_used, attrs.is_artificial);
 
-                    type_handled = cxx_method_decl != NULL;
-                    // Artificial methods are always handled even when we
-                    // don't create a new declaration for them.
-                    type_handled |= attrs.is_artificial;
 
-                    if (cxx_method_decl) {
-                      LinkDeclContextToDIE(cxx_method_decl, die);
 
-                      ClangASTMetadata metadata;
-                      metadata.SetUserID(die.GetID());
 
-                      if (!object_pointer_name.empty()) {
-                        metadata.SetObjectPtrName(
-                            object_pointer_name.c_str());
-                        LLDB_LOGF(log,
-                                  "Setting object pointer name: %s on method "
-                                  "object %p.\n",
-                                  object_pointer_name.c_str(),
-                                  static_cast<void *>(cxx_method_decl));
-                      }
-                      m_ast.SetMetadata(cxx_method_decl, metadata);
-                    } else {
-                      ignore_containing_context = true;
-                    }
-                  }
-                }
-              } else {
-                // We were asked to parse the type for a method in a
-                // class, yet the class hasn't been asked to complete
-                // itself through the clang::ExternalASTSource protocol,
-                // so we need to just have the class complete itself and
-                // do things the right way, then our
-                // DIE should then have an entry in the
-                // dwarf->GetDIEToType() map. First
-                // we need to modify the dwarf->GetDIEToType() so it
-                // doesn't think we are trying to parse this DIE
-                // anymore...
-                dwarf->GetDIEToType()[die.GetDIE()] = NULL;
-
-                // Now we get the full type to force our class type to
-                // complete itself using the clang::ExternalASTSource
-                // protocol which will parse all base classes and all
-                // methods (including the method for this DIE).
-                class_type->GetFullCompilerType();
-
-                // The type for this DIE should have been filled in the
-                // function call above
-                Type *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
-                if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
-                  return type_ptr->shared_from_this();
-                }
-
-                // FIXME This is fixing some even uglier behavior but we
-                // really need to
-                // uniq the methods of each class as well as the class
-                // itself. <rdar://problem/11240464>
-                type_handled = true;
-              }
             }
           }
         }
       }
     }
 
     if (!type_handled) {
       clang::FunctionDecl *function_decl = nullptr;
DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
   TypeSP type_sp;
   CompilerType clang_type;
   const dw_tag_t tag = die.Tag();
   SymbolFileDWARF *dwarf = die.GetDWARF();
   LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
 
+  GenerationBumper bumper(m_ast);
+
+  clang::DeclContext *decl_ctx =
+      GetClangDeclContextContainingDIE(die, nullptr);
+
+  const bool should_directly_complete = DirectlyCompleteType(decl_ctx, attrs);
   // UniqueDWARFASTType is large, so don't create a local variables on the
   // stack, put it on the heap. This function is often called recursively and
   // clang isn't good at sharing the stack space for variables in different
   // blocks.
   auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>();
 
   ConstString unique_typename(attrs.name);
   Declaration unique_decl(attrs.decl);
if (attrs.is_forward_declaration) {
     }
   }
   assert(tag_decl_kind != -1);
   (void)tag_decl_kind;
   bool clang_type_was_created = false;
   clang_type.SetCompilerType(
       &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
   if (!clang_type) {
-    clang::DeclContext *decl_ctx =
-        GetClangDeclContextContainingDIE(die, nullptr);
-
     PrepareContextToReceiveMembers(m_ast, GetClangASTImporter(), decl_ctx, die,
                                    attrs.name.GetCString());
 
     if (attrs.accessibility == eAccessNone && decl_ctx) {
       // Check the decl context that contains this class/struct/union. If
       // it is a class we must give it an accessibility.
       const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
       if (DeclKindIsCXXClass(containing_decl_kind))
if (attrs.name.GetStringRef().contains('<')) {
                 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;
 
         m_ast.SetMetadata(class_template_decl, metadata);
         m_ast.SetMetadata(class_specialization_decl, metadata);
+        RegisterDIE(die.GetDIE(), clang_type);
+        bumper.engage();
       }
     }
 
     if (!clang_type_was_created) {
       clang_type_was_created = true;
       clang_type = m_ast.CreateRecordType(
           decl_ctx, GetOwningClangModule(die), attrs.accessibility,
           attrs.name.GetCString(), tag_decl_kind, attrs.class_language,
           &metadata, attrs.exports_symbols);
+      RegisterDIE(die.GetDIE(), clang_type);
+      if (!should_directly_complete)
+        bumper.engage();
     }
   }
 
   // Store a forward declaration to this class type in case any
   // parameters in any class methods need it for the clang types for
   // function prototypes.
-  LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
+  LinkDeclContextToDIE(GetClangDeclContextContainingDIE(die, nullptr), die);
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       LLDB_INVALID_UID, Type::eEncodingIsUID, &attrs.decl, clang_type,
       Type::ResolveState::Forward,
       TypePayloadClang(OptionalClangModuleID(), attrs.is_complete_objc_class));
 
   // Add our type to the unique type map so we don't end up creating many
   // copies of the same type over and over in the ASTContext for our
   // module
   unique_ast_entry_up->m_type_sp = type_sp;
   unique_ast_entry_up->m_die = die;
   unique_ast_entry_up->m_declaration = unique_decl;
   unique_ast_entry_up->m_byte_size = attrs.byte_size.getValueOr(0);
   dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename,
                                            *unique_ast_entry_up);
 
   if (!attrs.is_forward_declaration) {
-    // Always start the definition for a class type so that if the class
-    // has child classes or types that require the class to be created
-    // for use as their decl contexts the class will be ready to accept
-    // these child definitions.
     if (!die.HasChildren()) {
       // No children for this struct/union/class, lets finish it
       if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
         TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
       } else {
         dwarf->GetObjectFile()->GetModule()->ReportError(
             "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
             "definition.\nPlease file a bug and attach the file at the "
if (!die.HasChildren()) {
         clang::RecordDecl *record_decl =
             TypeSystemClang::GetAsRecordDecl(clang_type);
         if (record_decl) {
           ClangASTImporter::LayoutInfo layout;
           layout.bit_size = *attrs.byte_size * 8;
           GetClangASTImporter().SetRecordLayout(record_decl, layout);
         }
       }
-    } else if (clang_type_was_created) {
-      // Start the definition if the class is not objective C since the
-      // underlying decls respond to isCompleteDefinition(). Objective
-      // C decls don't respond to isCompleteDefinition() so we can't
-      // start the declaration definition right away. For C++
-      // class/union/structs we want to start the definition in case the
-      // class is needed as the declaration context for a contained class
-      // or type without the need to complete that type..
-
-      if (attrs.class_language != eLanguageTypeObjC &&
-          attrs.class_language != eLanguageTypeObjC_plus_plus)
-        TypeSystemClang::StartTagDeclarationDefinition(clang_type);
-
+    } else if (clang_type_was_created && !should_directly_complete) {
       // Leave this as a forward declaration until we need to know the
       // details of the type. lldb_private::Type will automatically call
       // the SymbolFile virtual function
       // "SymbolFileDWARF::CompleteType(Type *)" When the definition
       // needs to be defined.
       assert(!dwarf->GetForwardDeclClangTypeToDie().count(
                  ClangUtil::RemoveFastQualifiers(clang_type)
                      .GetOpaqueQualType()) &&
              "Type already in the forward declaration map!");
       // Can't assume m_ast.GetSymbolFile() is actually a
       // SymbolFileDWARF, it can be a SymbolFileDWARFDebugMap for Apple
       // binaries.
       dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
           clang_type.GetOpaqueQualType();
       dwarf->GetForwardDeclClangTypeToDie().try_emplace(
           ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType(),
           *die.GetDIERef());
-      m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true);
     }
   }
 
-  // If we made a clang type, set the trivial abi if applicable: We only
-  // do this for pass by value - which implies the Trivial ABI. There
-  // isn't a way to assert that something that would normally be pass by
-  // value is pass by reference, so we ignore that attribute if set.
-  if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_value) {
-    clang::CXXRecordDecl *record_decl =
-        m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
-    if (record_decl && record_decl->getDefinition()) {
-      record_decl->setHasTrivialSpecialMemberForCall();
-    }
-  }
+  if (should_directly_complete)
+    m_to_complete.push_back({clang_type, die, type_sp});
 
-  if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_reference) {
-    clang::CXXRecordDecl *record_decl =
-        m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
-    if (record_decl)
-      record_decl->setArgPassingRestrictions(
-          clang::RecordDecl::APK_CannotPassInRegs);
-  }
   return type_sp;
 }
 
 // DWARF parsing functions
 
 class DWARFASTParserClang::DelayedAddObjCClassProperty {
 public:
   DelayedAddObjCClassProperty(
bool DWARFASTParserClang::ParseTemplateDIE(
   case DW_TAG_GNU_template_parameter_pack: {
     template_param_infos.packed_args =
         std::make_unique<TypeSystemClang::TemplateParameterInfos>();
     for (DWARFDIE child_die : die.children()) {
       if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
         return false;
     }
     if (const char *name = die.GetName()) {
-      template_param_infos.pack_name = name;
+      template_param_infos.pack_name = std::string(name);
     }
     return true;
   }
   case DW_TAG_GNU_template_template_param:
     is_template_template_argument = true;
     LLVM_FALLTHROUGH;
   case DW_TAG_template_type_parameter:
   case DW_TAG_template_value_parameter: {
default:
       break;
     }
   }
   return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
 bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
                                              lldb_private::Type *type,
-                                             CompilerType &clang_type) {
+                                             CompilerType clang_type) {
+  if (!m_currently_parsed_record_dies.insert(die.GetDIE()).second) {
+    return true;
+  }
+
   const dw_tag_t tag = die.Tag();
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
   ClangASTImporter::LayoutInfo layout_info;
 
-  if (die.HasChildren()) {
-    const bool type_is_objc_object_or_interface =
-        TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type);
-    if (type_is_objc_object_or_interface) {
-      // For objective C we don't start the definition when the class is
-      // created.
-      TypeSystemClang::StartTagDeclarationDefinition(clang_type);
-    }
+  ParsedDWARFTypeAttributes attrs(die);
 
-    AccessType default_accessibility = eAccessNone;
-    if (tag == DW_TAG_structure_type) {
-      default_accessibility = eAccessPublic;
-    } else if (tag == DW_TAG_union_type) {
-      default_accessibility = eAccessPublic;
-    } else if (tag == DW_TAG_class_type) {
-      default_accessibility = eAccessPrivate;
-    }
+  if (attrs.is_forward_declaration)
+    return true;
+
+  clang::DeclContext *decl_ctx =
+      GetClangDeclContextContainingDIE(die, nullptr);
+
+  if (!DirectlyCompleteType(decl_ctx, attrs)) {
+    clang_type = m_ast.RedeclTagDecl(clang_type);
+    RegisterDIE(die.GetDIE(), clang_type);
+  }
+  TypeSystemClang::StartTagDeclarationDefinition(clang_type);
 
-    std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
-    // Parse members and base classes first
-    std::vector<DWARFDIE> member_function_dies;
+  std::vector<int> member_accessibilities;
 
-    DelayedPropertyList delayed_properties;
-    ParseChildMembers(die, clang_type, bases, member_function_dies,
-                      delayed_properties, default_accessibility, layout_info);
+  ParseChildMembers(die, clang_type, bases,
+                    member_function_dies, delayed_properties,
+                    default_accessibility, layout_info);
 
-    // Now parse any methods if there were any...
-    for (const DWARFDIE &die : member_function_dies)
-      dwarf->ResolveType(die);
 
-    if (type_is_objc_object_or_interface) {
-      ConstString class_name(clang_type.GetTypeName());
-      if (class_name) {
-        dwarf->GetObjCMethods(class_name, [&](DWARFDIE method_die) {
-          method_die.ResolveType();
-          return true;
-        });
-
-        for (DelayedAddObjCClassProperty &property : delayed_properties)
-          property.Finalize();
-      }
-    }
+  const bool type_is_objc_object_or_interface =
+      TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type);
 
-    if (!bases.empty()) {
-      // Make sure all base classes refer to complete types and not forward
-      // declarations. If we don't do this, clang will crash with an
-      // assertion in the call to clang_type.TransferBaseClasses()
-      for (const auto &base_class : bases) {
-        clang::TypeSourceInfo *type_source_info =
-            base_class->getTypeSourceInfo();
-        if (type_source_info)
-          RequireCompleteType(m_ast.GetType(type_source_info->getType()));
-      }
 
-      m_ast.TransferBaseClasses(clang_type.GetOpaqueQualType(),
-                                std::move(bases));
-    }
+
+  // If we made a clang type, set the trivial abi if applicable: We only
+  // do this for pass by value - which implies the Trivial ABI. There
+  // isn't a way to assert that something that would normally be pass by
+  // value is pass by reference, so we ignore that attribute if set.
+  if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_value) {
+    clang::CXXRecordDecl *record_decl =
+        m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
+    if (record_decl && record_decl->getDefinition()) {
+      record_decl->setHasTrivialSpecialMemberForCall();
+    }
+  }
+
+  if (attrs.calling_convention == llvm::dwarf::DW_CC_pass_by_reference) {
+    clang::CXXRecordDecl *record_decl =
+        m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
+    if (record_decl)
+      record_decl->setArgPassingRestrictions(
+          clang::RecordDecl::APK_CannotPassInRegs);
   }
 
   m_ast.AddMethodOverridesForCXXRecordType(clang_type.GetOpaqueQualType());
   TypeSystemClang::BuildIndirectFields(clang_type);
   TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
 
-  if (!layout_info.field_offsets.empty() || !layout_info.base_offsets.empty() ||
-      !layout_info.vbase_offsets.empty()) {
+  clang::CXXRecordDecl *record_decl = m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
+  if (record_decl && !GetClangASTImporter().HasRecordLayout(record_decl)) {
     if (type)
       layout_info.bit_size = type->GetByteSize(nullptr).getValueOr(0) * 8;
     if (layout_info.bit_size == 0)
       layout_info.bit_size =
           die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
 
-    clang::CXXRecordDecl *record_decl =
-        m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
-    if (record_decl)
-      GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
   }
-
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteEnumType(const DWARFDIE &die,
                                            lldb_private::Type *type,
                                            CompilerType &clang_type) {
   if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type->GetByteSize(nullptr).getValueOr(0), die);
     }
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   }
+
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
   std::lock_guard<std::recursive_mutex> guard(
       dwarf->GetObjectFile()->GetModule()->GetMutex());
 
-  // Disable external storage for this type so we don't get anymore
-  // clang::ExternalASTSource queries for this type.
-  m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), false);
-
   if (!die)
     return false;
 
   const dw_tag_t tag = die.Tag();
 
   Log *log =
       nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
   if (log)
if (clang_decl_ctx)
       return clang_decl_ctx;
   }
   return m_ast.GetTranslationUnitDecl();
 }
 
 clang::DeclContext *
 DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
   if (die) {
+    DIEToRecordMap::iterator pos2 = m_die_to_record_map.find(die.GetDIE());
+    if (pos2 != m_die_to_record_map.end())
+      return pos2->second;
+    DIEToObjCInterfaceMap::iterator pos3 = m_die_to_objc_interface_map.find(die.GetDIE());
+    if (pos3 != m_die_to_objc_interface_map.end())
+      return pos3->second;
     DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
     if (pos != m_die_to_decl_ctx.end())
       return pos->second;
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

 #include "PdbAstBuilder.h"
 
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
bool PdbAstBuilder::CompleteType(clang::QualType qt) {
   if (!tag)
     return false;
 
   return CompleteTagDecl(*tag);
 }
 
 bool PdbAstBuilder::CompleteTagDecl(clang::TagDecl &tag) {
   // If this is not in our map, it's an error.
-  auto status_iter = m_decl_to_status.find(&tag);
+  auto status_iter = m_decl_to_status.find(tag.getFirstDecl());
   lldbassert(status_iter != m_decl_to_status.end());
 
   // If it's already complete, just return.
   DeclStatus &status = status_iter->second;
   if (status.resolved)
     return true;
 
   PdbTypeSymId type_id = PdbSymUid(status.uid).asTypeSym();
 
   lldbassert(IsTagRecord(type_id, m_index.tpi()));
 
-  clang::QualType tag_qt = m_clang.getASTContext().getTypeDeclType(&tag);
-  TypeSystemClang::SetHasExternalStorage(tag_qt.getAsOpaquePtr(), false);
-
   TypeIndex tag_ti = type_id.index;
   CVType cvt = m_index.tpi().getType(tag_ti);
   if (cvt.kind() == LF_MODIFIER)
     tag_ti = LookThroughModifierRecord(cvt);
 
   PdbTypeSymId best_ti = GetBestPossibleDecl(tag_ti, m_index.tpi());
   cvt = m_index.tpi().getType(best_ti.index);
   lldbassert(IsTagRecord(cvt));
 
   if (IsForwardRefUdt(cvt)) {
     // If we can't find a full decl for this forward ref anywhere in the debug
     // info, then we have no way to complete it.
     return false;
   }
 
   TypeIndex field_list_ti = GetFieldListIndex(cvt);
   CVType field_list_cvt = m_index.tpi().getType(field_list_ti);
   if (field_list_cvt.kind() != LF_FIELDLIST)
     return false;
 
   // Visit all members of this class, then perform any finalization necessary
   // to complete the class.
-  CompilerType ct = ToCompilerType(tag_qt);
+  CompilerType ct = m_clang.RedeclTagDecl(m_clang.GetTypeForDecl(&tag));
+  m_clang.StartTagDeclarationDefinition(ct);
   UdtRecordCompleter completer(best_ti, ct, tag, *this, m_index);
   auto error =
       llvm::codeview::visitMemberRecordStream(field_list_cvt.data(), completer);
   completer.complete();
 
   status.resolved = true;
   if (!error)
     return true;
clang::QualType PdbAstBuilder::CreateRecordType(PdbTypeSymId id,
   metadata.SetIsDynamicCXXType(false);
 
   CompilerType ct =
       m_clang.CreateRecordType(context, OptionalClangModuleID(), access, uname,
                                ttk, lldb::eLanguageTypeC_plus_plus, &metadata);
 
   lldbassert(ct.IsValid());
 
-  TypeSystemClang::StartTagDeclarationDefinition(ct);
-
   // Even if it's possible, don't complete it at this point. Just mark it
   // forward resolved, and if/when LLDB needs the full definition, it can
   // ask us.
   clang::QualType result =
       clang::QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
 
-  TypeSystemClang::SetHasExternalStorage(result.getAsOpaquePtr(), true);
   return result;
 }
 
 clang::Decl *PdbAstBuilder::TryGetDecl(PdbSymUid uid) const {
   auto iter = m_uid_to_decl.find(toOpaqueUid(uid));
   if (iter != m_uid_to_decl.end())
     return iter->second;
   return nullptr;
if (cvt.kind() == LF_POINTER) {
     PointerRecord pointer;
     llvm::cantFail(
         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
     return CreatePointerType(pointer);
   }
 
   if (IsTagRecord(cvt)) {
     CVTagRecord tag = CVTagRecord::create(cvt);
+    auto indicate_delayed_definition = llvm::make_scope_exit([this](){
+      m_clang.BumpGenerationCounter();
+    });
     if (tag.kind() == CVTagRecord::Union)
       return CreateRecordType(type.index, tag.asUnion());
     if (tag.kind() == CVTagRecord::Enum)
       return CreateEnumType(type.index, tag.asEnum());
     return CreateRecordType(type.index, tag.asClass());
   }
 
   if (cvt.kind() == LF_ARRAY) {
if (best_type.index != type.index) {
     return qt;
   }
 
   // This is either a full decl, or a forward decl with no matching full decl
   // in the debug info.
   qt = CreateType(type);
   m_uid_to_type[toOpaqueUid(type)] = qt;
   if (IsTagRecord(type, m_index.tpi())) {
-    clang::TagDecl *tag = qt->getAsTagDecl();
+    clang::TagDecl *tag = ClangUtil::GetAsTagDecl(m_clang.GetType(qt));
     lldbassert(m_decl_to_status.count(tag) == 0);
 
-    DeclStatus &status = m_decl_to_status[tag];
+    DeclStatus &status = m_decl_to_status[tag->getFirstDecl()];
     status.uid = uid;
     status.resolved = false;
   }
   return qt;
 }
 
 clang::FunctionDecl *
 PdbAstBuilder::GetOrCreateFunctionDecl(PdbCompilandSymId func_id) {
clang::QualType PdbAstBuilder::CreateEnumType(PdbTypeSymId id,
   std::tie(decl_context, uname) = CreateDeclInfoForType(er, id.index);
   clang::QualType underlying_type = GetOrCreateType(er.UnderlyingType);
 
   Declaration declaration;
   CompilerType enum_ct = m_clang.CreateEnumerationType(
       uname.c_str(), decl_context, OptionalClangModuleID(), declaration,
       ToCompilerType(underlying_type), er.isScoped());
 
-  TypeSystemClang::StartTagDeclarationDefinition(enum_ct);
-  TypeSystemClang::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true);
-
   return clang::QualType::getFromOpaquePtr(enum_ct.GetOpaqueQualType());
 }
 
 clang::QualType PdbAstBuilder::CreateArrayType(const ArrayRecord &ar) {
   clang::QualType element_type = GetOrCreateType(ar.ElementType);
 
   uint64_t element_count =
       ar.Size / GetSizeOfType({ar.ElementType}, m_index.tpi());

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

 namespace clang {
 class FileManager;
 class HeaderSearch;
 class ModuleMap;
 } // namespace clang
 
 namespace lldb_private {
 
+class ClangExternalASTSourceCallbacks;
 class ClangASTMetadata;
 class ClangASTSource;
 class Declaration;
 
 /// A Clang module ID.
 class OptionalClangModuleID {
   unsigned m_id = 0;
 
public:
   /// \param qt The QualType for a type that belongs to the ASTContext of this
   ///           TypeSystemClang.
   /// \return The CompilerType representing the given QualType. If the
   ///         QualType's type pointer is a nullptr then the function returns an
   ///         invalid CompilerType.
   CompilerType GetType(clang::QualType qt) {
     if (qt.getTypePtrOrNull() == nullptr)
       return CompilerType();
-    // Check that the type actually belongs to this TypeSystemClang.
-    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);
 
+  void BumpGenerationCounter();
+
   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) {
+    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 *
public:
   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 CompleteTagDecl(const clang::TagDecl *);
 
-  void CompleteObjCInterfaceDecl(clang::ObjCInterfaceDecl *);
+  void CompleteObjCInterfaceDecl(const clang::ObjCInterfaceDecl *);
+
+  CompilerType RedeclTagDecl(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:
   /// Returns the internal type name for the given NamedDecl using the
   /// type printing policy.
   std::string GetTypeNameForDecl(const clang::NamedDecl *named_decl);
 
   const clang::ClassTemplateSpecializationDecl *
   GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
 
   // Classes that inherit from TypeSystemClang can see and modify these
+  ClangExternalASTSourceCallbacks *m_ast_callbacks = nullptr;
   std::string m_target_triple;
   std::unique_ptr<clang::ASTContext> m_ast_up;
   std::unique_ptr<clang::LangOptions> m_language_options_up;
   std::unique_ptr<clang::FileManager> m_file_manager_up;
   std::unique_ptr<clang::SourceManager> m_source_manager_up;
   std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_up;
   std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_up;
   std::shared_ptr<clang::TargetOptions> m_target_options_rp;
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;
 
+  struct ClassTemplateRedeclInfo {
+    TemplateParameterInfos m_template_args;
+  };
+
+  typedef llvm::DenseMap<const clang::Decl *, ClassTemplateRedeclInfo> ClassTemplateRedeclInfoMap;
+  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

 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Sema/Sema.h"
 
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Threading.h"
+#include "llvm/ADT/ScopeExit.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
 #include "Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h"
 #include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
   // optimization level and -fno-inline, not actually whether the backend has
   // inlining enabled.
   //
   // FIXME: This is affected by other options (-fno-inline).
   Opts.NoInlineDefine = !Opt;
 
   // This is needed to allocate the extra space for the owning module
   // on each decl.
+  Opts.Modules = true;
   Opts.ModulesLocalVisibility = 1;
 }
 
 TypeSystemClang::TypeSystemClang(llvm::StringRef name,
                                  llvm::Triple target_triple) {
   m_display_name = name.str();
   if (!target_triple.str().empty())
     SetTargetTriple(target_triple.str());
void TypeSystemClang::CreateASTContext() {
   // built
   TargetInfo *target_info = getTargetInfo();
   if (target_info)
     m_ast_up->InitBuiltinTypes(*target_info);
 
   GetASTMap().Insert(m_ast_up.get(), this);
 
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_up(
-      new ClangExternalASTSourceCallbacks(*this));
+      m_ast_callbacks = new ClangExternalASTSourceCallbacks(*this));
   SetExternalSource(ast_source_up);
 }
 
 TypeSystemClang *TypeSystemClang::GetASTContext(clang::ASTContext *ast) {
   TypeSystemClang *clang_ast = GetASTMap().Lookup(ast);
   return clang_ast;
 }
 
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));
+  return GetType(getASTContext().getTypeDeclType(decl, decl->getPreviousDecl()));
 }
 
-CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
-  return GetType(getASTContext().getObjCInterfaceType(decl));
+CompilerType TypeSystemClang::GetTypeForDecl(const ObjCInterfaceDecl *decl) {
+  // FIXME: The Objective-C interface variant probably also doesn't need const.
+  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::DeclContext *decl_ctx, OptionalClangModuleID owning_module,
+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,
+    return CreateObjCDecl(name, decl_ctx, owning_module, isForwardDecl,
                            isInternal, metadata);
   }
 
   // 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;
   }
-  return CompilerType();
+  return nullptr;
+}
+
+void TypeSystemClang::BumpGenerationCounter() {
+  if (m_ast_up)
+    m_ast_up->getExternalSource()->incrementGeneration(*m_ast_up);
 }
 
 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, const char *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);
ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
 
   class_template_decl = ClassTemplateDecl::CreateDeserialized(ast, 0);
   // What decl context do we use here? TU? The actual decl context?
   class_template_decl->setDeclContext(decl_ctx);
   class_template_decl->setDeclName(decl_name);
   class_template_decl->init(template_cxx_decl, template_param_list);
   template_cxx_decl->setDescribedClassTemplate(class_template_decl);
   SetOwningModule(class_template_decl, owning_module);
+  ast.getInjectedClassNameType(template_cxx_decl,
+                               class_template_decl->getInjectedClassNameSpecialization());
 
   if (class_template_decl) {
     if (access_type != eAccessNone)
       class_template_decl->setAccess(
           ConvertAccessTypeToAccessSpecifier(access_type));
 
     decl_ctx->addDecl(class_template_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(
TypeSystemClang::CreateClassTemplateSpecializationDecl(
   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);
 
+  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 (decl && 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,
bool TypeSystemClang::GetCompleteDecl(clang::ASTContext *ast,
 
   if (!ast_source)
     return false;
 
   if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) {
     if (tag_decl->isCompleteDefinition())
       return true;
 
-    if (!tag_decl->hasExternalLexicalStorage())
-      return false;
-
     ast_source->CompleteType(tag_decl);
 
-    return !tag_decl->getTypeForDecl()->isIncompleteType();
+    tag_decl = tag_decl->getDefinition();
+
+    return tag_decl && !tag_decl->getTypeForDecl()->isIncompleteType();
   } else if (clang::ObjCInterfaceDecl *objc_interface_decl =
                  llvm::dyn_cast<clang::ObjCInterfaceDecl>(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);
 }
 
+static const clang::Decl *GetDeclForMetadataStorage(const clang::Decl *d) {
+  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())
case clang::Type::Enum:
     return llvm::cast<clang::EnumType>(qual_type)->getDecl();
   default:
     break;
   }
   // No DeclContext in this type...
   return nullptr;
 }
 
-static bool GetCompleteQualType(clang::ASTContext *ast,
+static QualType GetCompleteQualType(clang::ASTContext *ast,
                                 clang::QualType qual_type,
                                 bool allow_completion = true) {
   qual_type = RemoveWrappingTypes(qual_type);
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::ConstantArray:
   case clang::Type::IncompleteArray:
   case clang::Type::VariableArray: {
     const clang::ArrayType *array_type =
         llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
 
     if (array_type)
       return GetCompleteQualType(ast, array_type->getElementType(),
                                  allow_completion);
   } break;
   case clang::Type::Record: {
     clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
-    if (cxx_record_decl) {
-      if (cxx_record_decl->hasExternalLexicalStorage()) {
-        const bool is_complete = cxx_record_decl->isCompleteDefinition();
-        const bool fields_loaded =
-            cxx_record_decl->hasLoadedFieldsFromExternalStorage();
-        if (is_complete && fields_loaded)
-          return true;
-
-        if (!allow_completion)
-          return false;
-
-        // Call the field_begin() accessor to for it to use the external source
-        // to load the fields...
-        clang::ExternalASTSource *external_ast_source =
-            ast->getExternalSource();
-        if (external_ast_source) {
-          external_ast_source->CompleteType(cxx_record_decl);
-          if (cxx_record_decl->isCompleteDefinition()) {
-            cxx_record_decl->field_begin();
-            cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
-          }
-        }
-      }
-    }
-    const clang::TagType *tag_type =
-        llvm::cast<clang::TagType>(qual_type.getTypePtr());
-    return !tag_type->isIncompleteType();
+    clang::CXXRecordDecl *def = cxx_record_decl->getDefinition();
+    if (!def)
+      return QualType();
+    return QualType(def->getTypeForDecl(), 0);
   } break;
 
   case clang::Type::Enum: {
     const clang::TagType *tag_type =
         llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
     if (tag_type) {
       clang::TagDecl *tag_decl = tag_type->getDecl();
       if (tag_decl) {
-        if (tag_decl->getDefinition())
-          return true;
-
-        if (!allow_completion)
-          return false;
-
-        if (tag_decl->hasExternalLexicalStorage()) {
-          if (ast) {
-            clang::ExternalASTSource *external_ast_source =
-                ast->getExternalSource();
-            if (external_ast_source) {
-              external_ast_source->CompleteType(tag_decl);
-              return !tag_type->isIncompleteType();
-            }
-          }
-        }
-        return false;
+        if (clang::TagDecl *def = tag_decl->getDefinition())
+          return QualType(def->getTypeForDecl(), 0);
+        return QualType(tag_decl->getTypeForDecl(), 0);
       }
     }
 
   } break;
   case clang::Type::ObjCObject:
   case clang::Type::ObjCInterface: {
     const clang::ObjCObjectType *objc_class_type =
         llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
-      // We currently can't complete objective C types through the newly added
-      // ASTContext because it only supports TagDecl objects right now...
-      if (class_interface_decl) {
-        if (class_interface_decl->getDefinition())
-          return true;
-
-        if (!allow_completion)
-          return false;
-
-        if (class_interface_decl->hasExternalLexicalStorage()) {
-          if (ast) {
-            clang::ExternalASTSource *external_ast_source =
-                ast->getExternalSource();
-            if (external_ast_source) {
-              external_ast_source->CompleteType(class_interface_decl);
-              return !objc_class_type->isIncompleteType();
-            }
-          }
-        }
-        return false;
-      }
+      if (!class_interface_decl)
+        return qual_type;
+      if (clang::ObjCInterfaceDecl *def = class_interface_decl->getDefinition())
+       return QualType(def->getTypeForDecl(), 0);
     }
   } break;
 
   case clang::Type::Attributed:
     return GetCompleteQualType(
         ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(),
         allow_completion);
 
   default:
     break;
   }
 
-  return true;
+  return qual_type;
 }
 
 static clang::ObjCIvarDecl::AccessControl
 ConvertAccessTypeToObjCIvarAccessControl(AccessType access) {
   switch (access) {
   case eAccessNone:
     return clang::ObjCIvarDecl::None;
   case eAccessPublic:

 
 bool TypeSystemClang::IsCompleteType(lldb::opaque_compiler_type_t type) {
   // If the type hasn't been lazily completed yet, complete it now so that we
   // can give the caller an accurate answer whether the type actually has a
   // definition. Without completing the type now we would just tell the user
   // the current (internal) completeness state of the type and most users don't
   // care (or even know) about this behavior.
   const bool allow_completion = true;
-  return GetCompleteQualType(&getASTContext(), GetQualType(type),
-                             allow_completion);
+  return !GetCompleteQualType(&getASTContext(), GetQualType(type),
+                             allow_completion).isNull();
 }
 
 bool TypeSystemClang::IsConst(lldb::opaque_compiler_type_t type) {
   return GetQualType(type).isConstQualified();
 }
 
 bool TypeSystemClang::IsCStringType(lldb::opaque_compiler_type_t type,
                                     uint32_t &length) {
if (!type)
     return false;
 
   clang::QualType qual_type(GetQualType(type));
   const clang::TagType *tag_type =
       llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
   if (tag_type) {
     clang::TagDecl *tag_decl = tag_type->getDecl();
     if (tag_decl)
-      return tag_decl->isCompleteDefinition();
+      return tag_decl->getDefinition();
     return false;
   } else {
     const clang::ObjCObjectType *objc_class_type =
         llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
     if (objc_class_type) {
       clang::ObjCInterfaceDecl *class_interface_decl =
           objc_class_type->getInterface();
       if (class_interface_decl)

 }
 
 // Type Completion
 
 bool TypeSystemClang::GetCompleteType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
   const bool allow_completion = true;
-  return GetCompleteQualType(&getASTContext(), GetQualType(type),
-                             allow_completion);
+  return !GetCompleteQualType(&getASTContext(), GetQualType(type),
+                             allow_completion).isNull();
 }
 
 ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type) {
   if (!type)
     return ConstString();
 
   clang::QualType qual_type(GetQualType(type));
 

 
 size_t
 TypeSystemClang::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) {
   size_t num_functions = 0;
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
     case clang::Type::Record:
-      if (GetCompleteQualType(&getASTContext(), qual_type)) {
+      qual_type = GetCompleteQualType(&getASTContext(), qual_type);
+      if (!qual_type.isNull()) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
         assert(record_decl);
         const clang::CXXRecordDecl *cxx_record_decl =
             llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
         if (cxx_record_decl)
           num_functions = std::distance(cxx_record_decl->method_begin(),
TypeSystemClang::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type,
   std::string name;
   MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
   CompilerType clang_type;
   CompilerDecl clang_decl;
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     switch (qual_type->getTypeClass()) {
     case clang::Type::Record:
-      if (GetCompleteQualType(&getASTContext(), qual_type)) {
+      qual_type = GetCompleteQualType(&getASTContext(), qual_type);
+      if (!qual_type.isNull()) {
         const clang::RecordType *record_type =
             llvm::cast<clang::RecordType>(qual_type.getTypePtr());
         const clang::RecordDecl *record_decl = record_type->getDecl();
         assert(record_decl);
         const clang::CXXRecordDecl *cxx_record_decl =
             llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
         if (cxx_record_decl) {
           auto method_iter = cxx_record_decl->method_begin();
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());
case clang::Type::Builtin:
     default:
       break;
     }
     break;
 
   case clang::Type::Complex:
     return 0;
   case clang::Type::Record:
-    if (GetCompleteQualType(&getASTContext(), qual_type)) {
+      qual_type = GetCompleteQualType(&getASTContext(), qual_type);
+      if (!qual_type.isNull()) {
       const clang::RecordType *record_type =
           llvm::cast<clang::RecordType>(qual_type.getTypePtr());
       const clang::RecordDecl *record_decl = record_type->getDecl();
       assert(record_decl);
       const clang::CXXRecordDecl *cxx_record_decl =
           llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
       if (cxx_record_decl) {
         if (omit_empty_base_classes) {
case clang::Type::Record:
           field_end = record_decl->field_end();
            field != field_end; ++field)
         ++num_children;
     }
     break;
 
   case clang::Type::ObjCObject:
   case clang::Type::ObjCInterface:
-    if (GetCompleteQualType(&getASTContext(), qual_type)) {
+      qual_type = GetCompleteQualType(&getASTContext(), qual_type);
+      if (!qual_type.isNull()) {
       const clang::ObjCObjectType *objc_class_type =
           llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
       assert(objc_class_type);
       if (objc_class_type) {
         clang::ObjCInterfaceDecl *class_interface_decl =
             objc_class_type->getInterface();
 
         if (class_interface_decl) {
+          auto *def = class_interface_decl->getDefinition();
+          class_interface_decl = def;
+          if (class_interface_decl) {
 
             clang::ObjCInterfaceDecl *superclass_interface_decl =
                 class_interface_decl->getSuperClass();
             if (superclass_interface_decl) {
               if (omit_empty_base_classes) {
                 if (ObjCDeclHasIVars(superclass_interface_decl, true))
                   ++num_children;
               } else
                 ++num_children;
             }
 
             num_children += class_interface_decl->ivar_size();
           }
         }
       }
+    }
     break;
 
   case clang::Type::LValueReference:
   case clang::Type::RValueReference:
   case clang::Type::ObjCObjectPointer: {
     CompilerType pointee_clang_type(GetPointeeType(type));
 
     uint32_t num_pointee_children = 0;
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()))
if (idx_is_valid && GetCompleteType(type)) {
           llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
       assert(objc_class_type);
       if (objc_class_type) {
         uint32_t child_idx = 0;
         clang::ObjCInterfaceDecl *class_interface_decl =
             objc_class_type->getInterface();
 
         if (class_interface_decl) {
-
           const clang::ASTRecordLayout &interface_layout =
               getASTContext().getASTObjCInterfaceLayout(class_interface_decl);
           clang::ObjCInterfaceDecl *superclass_interface_decl =
               class_interface_decl->getSuperClass();
           if (superclass_interface_decl) {
             if (omit_empty_base_classes) {
               CompilerType base_class_clang_type =
                   GetType(getASTContext().getObjCInterfaceType(
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(
     bool is_artificial, bool is_variadic, bool is_objc_direct_call) {
   if (!type || !method_clang_type.IsValid())
     return nullptr;
 
   clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
 
   if (class_interface_decl == nullptr)
     return nullptr;
+  class_interface_decl = class_interface_decl->getDefinition();
+  if (class_interface_decl == nullptr)
+    return nullptr;
+
   TypeSystemClang *lldb_ast =
       llvm::dyn_cast<TypeSystemClang>(type.GetTypeSystem());
   if (lldb_ast == nullptr)
     return nullptr;
   clang::ASTContext &ast = lldb_ast->getASTContext();
 
   const char *selector_start = ::strchr(name, ' ');
   if (selector_start == 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();
+        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();
+        clang::ObjCInterfaceDecl *def = interface_decl->getMostRecentDecl();
+        def->startDefinition();
         return true;
       }
     }
   }
   return false;
 }
 
 bool TypeSystemClang::CompleteTagDeclarationDefinition(
if (auto *cxx_record_decl = llvm::dyn_cast<CXXRecordDecl>(tag_decl)) {
         if (cxx_record_decl->needsImplicitCopyConstructor())
           cxx_record_decl->setImplicitCopyConstructorIsDeleted();
         if (cxx_record_decl->needsImplicitCopyAssignment())
           cxx_record_decl->setImplicitCopyAssignmentIsDeleted();
       }
 
       if (!cxx_record_decl->isCompleteDefinition())
         cxx_record_decl->completeDefinition();
-      cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
-      cxx_record_decl->setHasExternalLexicalStorage(false);
-      cxx_record_decl->setHasExternalVisibleStorage(false);
       return true;
     }
   }
 
   const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>();
 
   if (!enutype)
     return false;
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());
if (template_param_infos.IsValid()) {
 
     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) {
+void TypeSystemClang::CompleteTagDecl(const clang::TagDecl *decl) {
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
-    CompilerType clang_type = GetTypeForDecl(decl);
+    CompilerType clang_type = GetTypeForDecl(const_cast<clang::TagDecl *>(decl));
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
 void TypeSystemClang::CompleteObjCInterfaceDecl(
-    clang::ObjCInterfaceDecl *decl) {
+    const clang::ObjCInterfaceDecl *decl) {
   SymbolFile *sym_file = GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
+CompilerType TypeSystemClang::RedeclTagDecl(CompilerType ct) {
+
+  if (clang::TagDecl *d = ClangUtil::GetAsTagDecl(ct)) {
+    if (clang::EnumDecl *e = dyn_cast<EnumDecl>(d)) {
+      Declaration decl;
+      CompilerType ct = CreateEnumerationType(e->getNameAsString().c_str(), d->getDeclContext()->getRedeclContext(), OptionalClangModuleID(), decl, GetType(e->getIntegerType()), e->isScoped());
+      clang::TagDecl *def = ClangUtil::GetAsTagDecl(ct);
+      def->setPreviousDecl(e);
+      return GetTypeForDecl(def);
+    }
+    if (auto *c = dyn_cast<ClassTemplateSpecializationDecl>(d)) {
+      auto redecl_info = m_class_template_redecl_infos.find(c);
+      assert(redecl_info != m_class_template_redecl_infos.end());
+      TemplateParameterInfos template_infos = redecl_info->second.m_template_args;
+      auto *ctd = CreateClassTemplateSpecializationDecl(d->getDeclContext()->getRedeclContext(), OptionalClangModuleID(), c->getSpecializedTemplate(), d->getTagKind(), template_infos);
+      ctd->setPreviousDecl(c);
+      return CompilerType(this, clang::QualType(ctd->getTypeForDecl(), 0U).getAsOpaquePtr());
+    }
+    clang::NamedDecl *res = CreateRecordDecl(d->getDeclContext()->getRedeclContext(),
+                                        OptionalClangModuleID(),
+                            lldb::eAccessPublic, d->getName(), d->getTagKind(),
+                            eLanguageTypeC_plus_plus, nullptr);
+    clang::TagDecl *td = llvm::cast<TagDecl>(res);
+    td->setPreviousDecl(d);
+    CompilerType actual_res = GetTypeForDecl(td);
+    assert(d->getTypeForDecl() == td->getTypeForDecl());
+    return actual_res;
+  }
+  if (clang::ObjCInterfaceDecl *d = ClangUtil::GetAsObjCDecl(ct)) {
+    clang::NamedDecl *res = CreateRecordDecl(d->getDeclContext()->getRedeclContext(), OptionalClangModuleID(),
+                            lldb::eAccessPublic, d->getName(), /*tag_kind=*/0,
+                            eLanguageTypeObjC, nullptr);
+    clang::ObjCInterfaceDecl *td = llvm::cast<ObjCInterfaceDecl>(res);
+    td->setPreviousDecl(d);
+    CompilerType actual_res = GetTypeForDecl(td);
+    assert(d->getTypeForDecl() == td->getTypeForDecl());
+    return actual_res;
+  }
+  return ct;
+}
+
 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/test/API/functionalities/lazy-loading/TestLazyLoading.py

class TestCase(TestBase):
     def get_ast_dump(self):
         """Returns the dumped Clang AST of the module as a string"""
         res = lldb.SBCommandReturnObject()
         ci = self.dbg.GetCommandInterpreter()
         ci.HandleCommand('target modules dump ast a.out', res)
         self.assertTrue(res.Succeeded())
         return res.GetOutput()
 
+    def get_ast_line_pairs(self):
+        ast = self.get_ast_dump()
+        lines = ast.splitlines()
+        pairs = []
+        for i in range(0, len(lines)):
+          line = lines[i].strip()
+          if i + 1 < len(lines):
+            next_line = lines[i + 1].strip()
+          else:
+            next_line = ""
+          pairs.append([line, next_line])
+        return pairs
+
     def decl_in_line(self, line, decl):
         """
         Returns true iff the given line declares the given Clang decl.
         The line is expected to be in the form of Clang's AST dump.
         """
         line = line.rstrip() + "\n"
         decl_kind = "-" + decl[0] + " "
         # Either the decl is somewhere in the line or at the end of
         # the line.
         decl_name = " " + decl[1] + " "
         decl_name_eol = " " + decl[1] + "\n"
         if not decl_kind in line:
           return False
         return decl_name in line or decl_name_eol in line
 
-    def decl_completed_in_line(self, line, decl):
+    def decl_completed_in_line(self, line):
         """
         Returns true iff the given line declares the given Clang decl and
-        the decl was completed (i.e., it has no undeserialized declarations
-        in it).
+        the decl was completed (i.e., it has definition data).
         """
-        return self.decl_in_line(line, decl) and not "<undeserialized declarations>" in line
+        return "|-DefinitionData" in line
 
     # The following asserts are used for checking if certain Clang declarations
     # were loaded or not since the target was created.
 
     def assert_decl_loaded(self, decl):
         """
         Asserts the given decl is currently loaded.
         Note: This test is about checking that types/declarations are not
         loaded. If this assert fails it is usually fine to turn it into a
         assert_decl_not_loaded or assert_decl_not_completed assuming LLDB's
         functionality has not suffered by not loading this declaration.
         """
-        ast = self.get_ast_dump()
+
+        pairs = self.get_ast_line_pairs()
         found = False
-        for line in ast.splitlines():
+        for line, next_line in pairs:
           if self.decl_in_line(line, decl):
             found = True
-            self.assertTrue(self.decl_completed_in_line(line, decl),
-                            "Should have called assert_decl_not_completed")
-        self.assertTrue(found, "Declaration no longer loaded " + str(decl) +
-            ".\nAST:\n" + ast)
+        self.assertTrue(found, "Declaration not loaded " + str(decl) +
+            ".\nAST:\n" + self.get_ast_dump())
+
+    def assert_decl_completed(self, decl):
+        """
+        Asserts that the given decl is currently completed in the module's
+        AST.
+        """
+        pairs = self.get_ast_line_pairs()
+        found = False
+        for line, next_line in pairs:
+          if self.decl_in_line(line, decl) and self.decl_completed_in_line(next_line):
+            found = True
+        self.assertTrue(found, "Declaration not completed " + str(decl) +
+            ".\nAST:\n" + self.get_ast_dump())
 
     def assert_decl_not_completed(self, decl):
         """
         Asserts that the given decl is currently not completed in the module's
-        AST. It may be loaded but then can can only contain undeserialized
-        declarations.
+        AST.
         """
-        ast = self.get_ast_dump()
+        pairs = self.get_ast_line_pairs()
         found = False
-        for line in ast.splitlines():
-          error_msg = "Unexpected completed decl: '" + line + "'.\nAST:\n" + ast
-          self.assertFalse(self.decl_completed_in_line(line, decl), error_msg)
+        for line, next_line in pairs:
+          if self.decl_in_line(line, decl) and self.decl_completed_in_line(next_line):
+            found = True
+        self.assertFalse(found, "Declaration not loaded or completed " + str(decl) +
+            ".\nAST:\n" + self.get_ast_dump())
 
     def assert_decl_not_loaded(self, decl):
         """
         Asserts that the given decl is currently not loaded in the module's
         AST.
         """
         ast = self.get_ast_dump()
         found = False
         for line in ast.splitlines():
-          error_msg = "Unexpected loaded decl: '" + line + "'\nAST:\n" + ast
-          self.assertFalse(self.decl_in_line(line, decl), error_msg)
+          self.assertFalse(self.decl_in_line(line, decl),
+                           "Unexpected loaded decl: '" + line + "'\nAST:\n" + ast)
 
 
     def clean_setup(self, location):
         """
         Runs to the line with the source line with the given location string
         and ensures that our module AST is empty.
         """
         lldbutil.run_to_source_breakpoint(self,
def test_addr_of_struct(self):
         """
         Prints the address of a local variable (which is a struct).
         """
         self.clean_setup(location="multiple locals function")
 
         self.expect("expr &struct_var", substrs=['(SomeStruct *) $0'])
 
         # We loaded SomeStruct.
-        self.assert_decl_loaded(self.some_struct_decl)
+        self.assert_decl_completed(self.some_struct_decl)
 
         # The member declarations should not be completed.
-        self.assert_decl_not_completed(self.struct_behind_ptr_decl)
-        self.assert_decl_not_completed(self.struct_behind_ref_decl)
+        self.assert_decl_completed(self.struct_behind_ptr_decl)
+        self.assert_decl_completed(self.struct_behind_ref_decl)
 
         # FIXME: The first member was behind a pointer so it shouldn't be
         # completed. Somehow LLDB really wants to load the first member, so
         # that is why have it defined here.
         self.assert_decl_loaded(self.struct_first_member_decl)
 
         # FIXME: We don't use these variables, but we seem to load all local
         # local variables.
         self.assert_decl_not_completed(self.other_struct_decl)
         self.assert_decl_not_completed(self.class_in_namespace_decl)
 
     @add_test_categories(["dwarf"])
     def test_class_function_access_member(self):
         self.clean_setup(location="class function")
 
         self.expect("expr member", substrs=['(ClassMember) $0'])
 
         # We loaded the current class we touched.
         self.assert_decl_loaded(self.class_we_enter_decl)
         # We loaded the unused members of this class.
         self.assert_decl_loaded(self.unused_class_member_decl)
-        self.assert_decl_not_completed(self.unused_class_member_ptr_decl)
+        self.assert_decl_completed(self.unused_class_member_ptr_decl)
         # We loaded the member we used.
         self.assert_decl_loaded(self.class_member_decl)
         # We didn't load the type of the unused static member.
         self.assert_decl_not_completed(self.class_static_member_decl)
 
         # This should not have loaded anything else.
         self.assert_decl_not_loaded(self.other_struct_decl)
         self.assert_decl_not_loaded(self.some_struct_decl)
         self.assert_decl_not_loaded(self.class_in_namespace_decl)
 

lldb/test/API/lang/c/modules/TestCModules.py

def test_expr(self):
             substrs=[
                 "FILE",
                 "_close"])
 
         # Check that the AST log contains exactly one definition of __sFILE.
         f = open(log_file)
         log_lines = f.readlines()
         f.close()
-        os.remove(log_file)
+#        os.remove(log_file)
+        print(log_file)
+        self.assertIn("struct __sFILE definition", " ".join(log_lines))
         self.assertEqual(" ".join(log_lines).count("struct __sFILE definition"),
                          1)
 
         self.expect("expr *myFile", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["a", "5", "b", "9"])
 
         self.expect(
             "expr MIN((uint64_t)2, (uint64_t)3)",

lldb/test/Shell/SymbolFile/NativePDB/ast-methods.cpp

 
 Struct s;
 
 int main(int argc, char **argv) {
   return 0;
 }
 
 // CHECK: TranslationUnitDecl
-// CHECK: |-CXXRecordDecl {{.*}} struct Struct definition
-// CHECK: | |-CXXMethodDecl {{.*}} simple_method 'void (){{.*}}'
-// CHECK: | |-CXXMethodDecl {{.*}} virtual_method 'void (){{.*}}' virtual
-// CHECK: | |-CXXMethodDecl {{.*}} static_method 'void ()' static
-// CHECK: | |-CXXMethodDecl {{.*}} overloaded_method 'int (){{.*}}'
-// CHECK: | |-CXXMethodDecl {{.*}} overloaded_method 'int (char){{.*}}'
-// CHECK: | | `-ParmVarDecl {{.*}} 'char'
-// CHECK: | `-CXXMethodDecl {{.*}} overloaded_method 'int (char, int, ...)'
-// CHECK: |   |-ParmVarDecl {{.*}} 'char'
-// CHECK: |   `-ParmVarDecl {{.*}} 'int'
+// CHECK: `-CXXRecordDecl {{.*}} struct Struct definition
+// CHECK:   |-CXXMethodDecl {{.*}} simple_method 'void (){{.*}}'
+// CHECK:   |-CXXMethodDecl {{.*}} virtual_method 'void (){{.*}}' virtual
+// CHECK:   |-CXXMethodDecl {{.*}} static_method 'void ()' static
+// CHECK:   |-CXXMethodDecl {{.*}} overloaded_method 'int (){{.*}}'
+// CHECK:   |-CXXMethodDecl {{.*}} overloaded_method 'int (char){{.*}}'
+// CHECK:   | `-ParmVarDecl {{.*}} 'char'
+// CHECK:   `-CXXMethodDecl {{.*}} overloaded_method 'int (char, int, ...)'
+// CHECK:     |-ParmVarDecl {{.*}} 'char'
+// CHECK:     `-ParmVarDecl {{.*}} 'int'

lldb/test/Shell/SymbolFile/NativePDB/bitfields.cpp

 // CHECK:   (char:2) F = '\x01'
 // CHECK:   (char:3) G = '\x02'
 // CHECK:   (char:3) H = '\x03'
 // CHECK: }
 //
 // CHECK: target modules dump ast
 // CHECK: Dumping clang ast for 1 modules.
 // CHECK: TranslationUnitDecl {{.*}}
-// CHECK: |-CXXRecordDecl {{.*}} struct Struct definition
-// CHECK: | |-FieldDecl {{.*}} A 'int'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 5
-// CHECK: | |-FieldDecl {{.*}} B 'int'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 7
-// CHECK: | |-FieldDecl {{.*}} C 'unsigned int'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 3
-// CHECK: | |-FieldDecl {{.*}} D 'unsigned int'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 15
-// CHECK: | |-FieldDecl {{.*}} E 'char'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 1
-// CHECK: | |-FieldDecl {{.*}} F 'char'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 2
-// CHECK: | |-FieldDecl {{.*}} G 'char'
-// CHECK: | | `-IntegerLiteral {{.*}} 'int' 3
-// CHECK: | `-FieldDecl {{.*}} H 'char'
-// CHECK: |   `-IntegerLiteral {{.*}} 'int' 3
+// CHECK: `-CXXRecordDecl {{.*}} struct Struct definition
+// CHECK:   |-FieldDecl {{.*}} A 'int'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 5
+// CHECK:   |-FieldDecl {{.*}} B 'int'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 7
+// CHECK:   |-FieldDecl {{.*}} C 'unsigned int'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 3
+// CHECK:   |-FieldDecl {{.*}} D 'unsigned int'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 15
+// CHECK:   |-FieldDecl {{.*}} E 'char'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 1
+// CHECK:   |-FieldDecl {{.*}} F 'char'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 2
+// CHECK:   |-FieldDecl {{.*}} G 'char'
+// CHECK:   | `-IntegerLiteral {{.*}} 'int' 3
+// CHECK:   `-FieldDecl {{.*}} H 'char'
+// CHECK:     `-IntegerLiteral {{.*}} 'int' 3

lldb/test/Shell/SymbolFile/NativePDB/global-classes.cpp

 // CHECK-NEXT:   (EnumType &) j = {{.*}}
 // CHECK-NEXT:   (double &) k = {{.*}}
 // CHECK-NEXT:   (unsigned long long &) l = {{.*}}
 // CHECK-NEXT:   (long long &) m = {{.*}}
 // CHECK-NEXT: }
 
 // CHECK: Dumping clang ast for 1 modules.
 // CHECK: TranslationUnitDecl {{.*}}
+// CHECK: |-CXXRecordDecl {{.*}} class ClassWithPadding
+// CHECK: |-VarDecl {{.*}} ClassWithPaddingInstance 'const ClassWithPadding'
 // CHECK: |-CXXRecordDecl {{.*}} class ClassWithPadding definition
 // CHECK: | |-FieldDecl {{.*}} a 'char'
 // CHECK: | |-FieldDecl {{.*}} b 'short'
 // CHECK: | |-FieldDecl {{.*}} c 'char[2]'
 // CHECK: | |-FieldDecl {{.*}} d 'int'
 // CHECK: | |-FieldDecl {{.*}} e 'char'
 // CHECK: | |-FieldDecl {{.*}} f 'int'
 // CHECK: | |-FieldDecl {{.*}} g 'long long'
 // CHECK: | |-FieldDecl {{.*}} h 'char[3]'
 // CHECK: | |-FieldDecl {{.*}} i 'long long'
 // CHECK: | |-FieldDecl {{.*}} j 'char[2]'
 // CHECK: | |-FieldDecl {{.*}} k 'long long'
 // CHECK: | |-FieldDecl {{.*}} l 'char'
 // CHECK: | `-FieldDecl {{.*}} m 'long long'
-// CHECK: |-VarDecl {{.*}} ClassWithPaddingInstance 'const ClassWithPadding'
+// CHECK: |-CXXRecordDecl {{.*}} class ClassNoPadding
+// CHECK: |-VarDecl {{.*}} ClassNoPaddingInstance 'const ClassNoPadding'
 // CHECK: |-CXXRecordDecl {{.*}} class ClassNoPadding definition
 // CHECK: | |-FieldDecl {{.*}} a 'unsigned char'
 // CHECK: | |-FieldDecl {{.*}} b 'char'
 // CHECK: | |-FieldDecl {{.*}} c 'bool'
 // CHECK: | |-FieldDecl {{.*}} d 'bool'
 // CHECK: | |-FieldDecl {{.*}} e 'short'
 // CHECK: | |-FieldDecl {{.*}} f 'unsigned short'
 // CHECK: | |-FieldDecl {{.*}} g 'unsigned int'
 // CHECK: | |-FieldDecl {{.*}} h 'int'
 // CHECK: | |-FieldDecl {{.*}} i 'unsigned long'
 // CHECK: | |-FieldDecl {{.*}} j 'long'
 // CHECK: | |-FieldDecl {{.*}} k 'float'
 // CHECK: | |-FieldDecl {{.*}} l 'EnumType'
 // CHECK: | |-FieldDecl {{.*}} m 'double'
 // CHECK: | |-FieldDecl {{.*}} n 'unsigned long long'
 // CHECK: | |-FieldDecl {{.*}} o 'long long'
 // CHECK: | `-FieldDecl {{.*}} p 'int[5]'
-// CHECK: |-VarDecl {{.*}} ClassNoPaddingInstance 'const ClassNoPadding'
 // CHECK: |-EnumDecl {{.*}} EnumType
 // CHECK: | |-EnumConstantDecl {{.*}} A 'EnumType'
 // CHECK: | `-EnumConstantDecl {{.*}} B 'EnumType'
+// CHECK: |-CXXRecordDecl {{.*}} struct DerivedClass
+// CHECK: |-VarDecl {{.*}} DC 'const DerivedClass'
 // CHECK: |-CXXRecordDecl {{.*}} struct DerivedClass definition
 // CHECK: | |-public 'BaseClass<int>'
 // CHECK: | |-FieldDecl {{.*}} DerivedMember 'int'
 // CHECK: | `-CXXConstructorDecl {{.*}} DerivedClass 'void (int, int)'
 // CHECK: |   |-ParmVarDecl {{.*}} 'int'
 // CHECK: |   `-ParmVarDecl {{.*}} 'int'
-// CHECK: |-VarDecl {{.*}} DC 'const DerivedClass'
 // CHECK: |-CXXRecordDecl {{.*}} struct BaseClass<int> definition
 // CHECK: | |-FieldDecl {{.*}} BaseMember 'int'
 // CHECK: | `-CXXMethodDecl {{.*}} BaseClass 'void (int)'
 // CHECK: |   `-ParmVarDecl {{.*}} 'int'
+// CHECK: |-CXXRecordDecl {{.*}} struct EBO
+// CHECK: |-VarDecl {{.*}} EBOC 'const EBO'
 // CHECK: |-CXXRecordDecl {{.*}} struct EBO definition
 // CHECK: | |-public 'EmptyBase'
 // CHECK: | |-FieldDecl {{.*}} Member 'int'
 // CHECK: | `-CXXConstructorDecl {{.*}} EBO 'void (int)'
 // CHECK: |   `-ParmVarDecl {{.*}} 'int'
-// CHECK: |-VarDecl {{.*}} EBOC 'const EBO'
 // CHECK: |-CXXRecordDecl {{.*}} struct EmptyBase definition
+// CHECK: |-CXXRecordDecl {{.*}} struct PaddedBases
+// CHECK: |-VarDecl {{.*}} PBC 'const PaddedBases'
 // CHECK: |-CXXRecordDecl {{.*}} struct PaddedBases definition
 // CHECK: | |-public 'BaseClass<char>'
 // CHECK: | |-public 'BaseClass<short>'
 // CHECK: | |-public 'BaseClass<int>'
 // CHECK: | |-FieldDecl {{.*}} DerivedMember 'long long'
 // CHECK: | `-CXXConstructorDecl {{.*}} PaddedBases 'void (char, short, int, long long)'
 // CHECK: |   |-ParmVarDecl {{.*}} 'char'
 // CHECK: |   |-ParmVarDecl {{.*}} 'short'
 // CHECK: |   |-ParmVarDecl {{.*}} 'int'
 // CHECK: |   `-ParmVarDecl {{.*}} 'long long'
-// CHECK: |-VarDecl {{.*}} PBC 'const PaddedBases'
 // CHECK: |-CXXRecordDecl {{.*}} struct BaseClass<char> definition
 // CHECK: | |-FieldDecl {{.*}} BaseMember 'int'
 // CHECK: | `-CXXMethodDecl {{.*}} BaseClass 'void (int)'
 // CHECK: |   `-ParmVarDecl {{.*}} 'int'
 // CHECK: |-CXXRecordDecl {{.*}} struct BaseClass<short> definition
 // CHECK: | |-FieldDecl {{.*}} BaseMember 'int'
 // CHECK: | `-CXXMethodDecl {{.*}} BaseClass 'void (int)'
 // CHECK: |   `-ParmVarDecl {{.*}} 'int'
+// CHECK: |-CXXRecordDecl {{.*}} struct <unnamed-type-UnnamedClassInstance>
+// CHECK: |-VarDecl {{.*}} UnnamedClassInstance 'const <unnamed-type-UnnamedClassInstance>'
 // CHECK: |-CXXRecordDecl {{.*}} struct <unnamed-type-UnnamedClassInstance> definition
 // CHECK: | |-FieldDecl {{.*}} x 'int'
 // CHECK: | `-FieldDecl {{.*}} EBOC 'EBO'
-// CHECK: |-VarDecl {{.*}} UnnamedClassInstance 'const <unnamed-type-UnnamedClassInstance>'
+// CHECK: |-CXXRecordDecl {{.*}} struct Pointers
+// CHECK: |-VarDecl {{.*}} PointersInstance 'const Pointers'
 // CHECK: |-CXXRecordDecl {{.*}} struct Pointers definition
 // CHECK: | |-FieldDecl {{.*}} a 'void *'
 // CHECK: | |-FieldDecl {{.*}} b 'char *'
 // CHECK: | |-FieldDecl {{.*}} c 'bool *'
 // CHECK: | |-FieldDecl {{.*}} e 'short *'
 // CHECK: | |-FieldDecl {{.*}} f 'unsigned short *'
 // CHECK: | |-FieldDecl {{.*}} g 'unsigned int *'
 // CHECK: | |-FieldDecl {{.*}} h 'int *'
 // CHECK: | |-FieldDecl {{.*}} i 'unsigned long *'
 // CHECK: | |-FieldDecl {{.*}} j 'long *'
 // CHECK: | |-FieldDecl {{.*}} k 'float *'
 // CHECK: | |-FieldDecl {{.*}} l 'EnumType *'
 // CHECK: | |-FieldDecl {{.*}} m 'double *'
 // CHECK: | |-FieldDecl {{.*}} n 'unsigned long long *'
 // CHECK: | `-FieldDecl {{.*}} o 'long long *'
-// CHECK: |-VarDecl {{.*}} PointersInstance 'const Pointers'
-// CHECK: |-CXXRecordDecl {{.*}} struct References definition
-// CHECK: | |-FieldDecl {{.*}} a 'char &'
-// CHECK: | |-FieldDecl {{.*}} b 'bool &'
-// CHECK: | |-FieldDecl {{.*}} c 'short &'
-// CHECK: | |-FieldDecl {{.*}} d 'unsigned short &'
-// CHECK: | |-FieldDecl {{.*}} e 'unsigned int &'
-// CHECK: | |-FieldDecl {{.*}} f 'int &'
-// CHECK: | |-FieldDecl {{.*}} g 'unsigned long &'
-// CHECK: | |-FieldDecl {{.*}} h 'long &'
-// CHECK: | |-FieldDecl {{.*}} i 'float &'
-// CHECK: | |-FieldDecl {{.*}} j 'EnumType &'
-// CHECK: | |-FieldDecl {{.*}} k 'double &'
-// CHECK: | |-FieldDecl {{.*}} l 'unsigned long long &'
-// CHECK: | `-FieldDecl {{.*}} m 'long long &'
-// CHECK: `-VarDecl {{.*}} ReferencesInstance 'const References'
+// CHECK: |-CXXRecordDecl {{.*}} struct References
+// CHECK: |-VarDecl {{.*}} ReferencesInstance 'const References'
+// CHECK: `-CXXRecordDecl {{.*}} struct References definition
+// CHECK:  |-FieldDecl {{.*}} a 'char &'
+// CHECK:   |-FieldDecl {{.*}} b 'bool &'
+// CHECK:   |-FieldDecl {{.*}} c 'short &'
+// CHECK:   |-FieldDecl {{.*}} d 'unsigned short &'
+// CHECK:   |-FieldDecl {{.*}} e 'unsigned int &'
+// CHECK:   |-FieldDecl {{.*}} f 'int &'
+// CHECK:   |-FieldDecl {{.*}} g 'unsigned long &'
+// CHECK:   |-FieldDecl {{.*}} h 'long &'
+// CHECK:   |-FieldDecl {{.*}} i 'float &'
+// CHECK:   |-FieldDecl {{.*}} j 'EnumType &'
+// CHECK:   |-FieldDecl {{.*}} k 'double &'
+// CHECK:   |-FieldDecl {{.*}} l 'unsigned long long &'
+// CHECK:   `-FieldDecl {{.*}} m 'long long &'
 
 int main(int argc, char **argv) {
   return 0;
 }

lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp

TEST_F(ClangExpressionDeclMapTest, TestPersistentDeclLookup) {
   NameSearchContext search(*target_ast, decls, name, dc);
 
   // Search and check that we found $persistent_class.
   decl_map->FindExternalVisibleDecls(search);
   EXPECT_EQ(1U, decls.size());
   EXPECT_EQ(decl_name, decls.front()->getQualifiedNameAsString());
   auto *record = llvm::cast<clang::RecordDecl>(decls.front());
   // The class was minimally imported from the scratch AST context.
-  EXPECT_TRUE(record->hasExternalLexicalStorage());
+  EXPECT_EQ(record->getDefinition(), nullptr);
 }

lldb/unittests/Symbol/TestClangASTImporter.cpp

 TEST_F(TestClangASTImporter, CopyDeclTagDecl) {
   // Tests that the ClangASTImporter::CopyDecl can copy TagDecls.
   clang_utils::SourceASTWithRecord source;
 
   std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   clang::Decl *imported =
-      importer.CopyDecl(&target_ast->getASTContext(), source.record_decl);
+      importer.CopyDecl(&target_ast->getASTContext(), source.fwd_decl);
   ASSERT_NE(nullptr, imported);
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = llvm::cast<clang::TagDecl>(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // We did a minimal import of the tag decl.
-  EXPECT_TRUE(imported_tag_decl->hasExternalLexicalStorage());
+  EXPECT_EQ(imported_tag_decl->getDefinition(), nullptr);
 
   // Check that origin was set for the imported declaration.
   ClangASTImporter::DeclOrigin origin = importer.GetDeclOrigin(imported);
   EXPECT_TRUE(origin.Valid());
   EXPECT_EQ(origin.ctx, &source.ast->getASTContext());
-  EXPECT_EQ(origin.decl, source.record_decl);
+  EXPECT_EQ(origin.decl, source.fwd_decl);
 }
 
 TEST_F(TestClangASTImporter, CopyTypeTagDecl) {
   // Tests that the ClangASTImporter::CopyType can copy TagDecls types.
   clang_utils::SourceASTWithRecord source;
 
   std::unique_ptr<TypeSystemClang> target_ast = clang_utils::createAST();
 
   ClangASTImporter importer;
   CompilerType imported = importer.CopyType(*target_ast, source.record_type);
   ASSERT_TRUE(imported.IsValid());
 
   // Check that we got the correct decl by just comparing their qualified name.
   clang::TagDecl *imported_tag_decl = ClangUtil::GetAsTagDecl(imported);
   EXPECT_EQ(source.record_decl->getQualifiedNameAsString(),
             imported_tag_decl->getQualifiedNameAsString());
   // We did a minimal import of the tag decl.
-  EXPECT_TRUE(imported_tag_decl->hasExternalLexicalStorage());
+  EXPECT_EQ(imported_tag_decl->getDefinition(), nullptr);
 
   // Check that origin was set for the imported declaration.
   ClangASTImporter::DeclOrigin origin =
       importer.GetDeclOrigin(imported_tag_decl);
   EXPECT_TRUE(origin.Valid());
   EXPECT_EQ(origin.ctx, &source.ast->getASTContext());
-  EXPECT_EQ(origin.decl, source.record_decl);
+  EXPECT_EQ(origin.decl, source.fwd_decl);
+
+  clang::Decl *imported_definition = importer.CopyDecl(&target_ast->getASTContext(), source.record_decl);
+  ASSERT_NE(imported_definition, nullptr);
+
+  clang::TagDecl *definition = imported_tag_decl->getDefinition();
+  ASSERT_EQ(definition, imported_definition);
+  EXPECT_EQ(definition, imported_tag_decl->getDefinition());
+  EXPECT_EQ(definition->getPreviousDecl(), imported_tag_decl);
 }
 
 TEST_F(TestClangASTImporter, CompleteFwdDeclWithOtherOrigin) {
   // Create an AST with a full type that is defined.
   clang_utils::SourceASTWithRecord source_with_definition;
 
   // Create an AST with a type thst is only a forward declaration with the
   // same name as the one in the other source.

lldb/unittests/Symbol/TestTypeSystemClang.cpp

TEST_F(TestTypeSystemClang, TestNotDeletingUserCopyCstrDueToMoveCStr) {
 
   // Complete the definition and check the created record.
   m_ast->CompleteTagDeclarationDefinition(t);
   auto *record = llvm::cast<CXXRecordDecl>(ClangUtil::GetAsTagDecl(t));
   EXPECT_TRUE(record->hasUserDeclaredCopyConstructor());
 }
 
 TEST_F(TestTypeSystemClang, AddMethodToObjCObjectType) {
-  // Create an interface decl and mark it as having external storage.
+  // Create an interface decl.
   CompilerType c = m_ast->CreateObjCClass("A", m_ast->GetTranslationUnitDecl(),
                                           OptionalClangModuleID(),
                                           /*IsForwardDecl*/ false,
                                           /*IsInternal*/ false);
-  ObjCInterfaceDecl *interface = m_ast->GetAsObjCInterfaceDecl(c);
-  m_ast->SetHasExternalStorage(c.GetOpaqueQualType(), true);
-  EXPECT_TRUE(interface->hasExternalLexicalStorage());
+  EXPECT_TRUE(m_ast->StartTagDeclarationDefinition(c));
 
   // Add a method to the interface.
   std::vector<CompilerType> args;
   CompilerType func_type =
       m_ast->CreateFunctionType(m_ast->GetBasicType(lldb::eBasicTypeInt),
                                 args.data(), args.size(), /*variadic*/ false,
                                 /*quals*/ 0, clang::CallingConv::CC_C);
   bool variadic = false;
   bool artificial = false;
   bool objc_direct = false;
   clang::ObjCMethodDecl *method = TypeSystemClang::AddMethodToObjCObjectType(
       c, "-[A foo]", func_type, lldb::eAccessPublic, artificial, variadic,
       objc_direct);
   ASSERT_NE(method, nullptr);
 
-  // The interface decl should still have external lexical storage.
-  EXPECT_TRUE(interface->hasExternalLexicalStorage());
-
   // Test some properties of the created ObjCMethodDecl.
   EXPECT_FALSE(method->isVariadic());
   EXPECT_TRUE(method->isImplicit());
   EXPECT_FALSE(method->isDirectMethod());
   EXPECT_EQ(method->getDeclName().getObjCSelector().getAsString(), "foo");
 }
 
 TEST_F(TestTypeSystemClang, GetFullyUnqualifiedType) {

lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h

 }
 
 /// Create a record with the given name and a field with the given type
 /// and name.
 inline CompilerType createRecordWithField(TypeSystemClang &ast,
                                           llvm::StringRef record_name,
                                           CompilerType field_type,
                                           llvm::StringRef field_name) {
-  CompilerType t = createRecord(ast, record_name);
+  CompilerType fwd_decl = createRecord(ast, record_name);
+  CompilerType t = ast.RedeclTagDecl(fwd_decl);
 
   TypeSystemClang::StartTagDeclarationDefinition(t);
   ast.AddFieldToRecordType(t, field_name, field_type,
                            lldb::AccessType::eAccessPublic, 7);
   TypeSystemClang::CompleteTagDeclarationDefinition(t);
 
-  return t;
+  return fwd_decl;
 }
 
 /// Constructs a TypeSystemClang that contains a single RecordDecl that contains
 /// a single FieldDecl. Utility class as this setup is a common starting point
 /// for unit test that exercise the ASTImporter.
 struct SourceASTWithRecord {
   std::unique_ptr<TypeSystemClang> ast;
   CompilerType record_type;
   clang::RecordDecl *record_decl = nullptr;
+  clang::RecordDecl *fwd_decl = nullptr;
   clang::FieldDecl *field_decl = nullptr;
   SourceASTWithRecord() {
     ast = createAST();
     record_type = createRecordWithField(
         *ast, "Source", ast->GetBasicType(lldb::BasicType::eBasicTypeChar),
         "a_field");
-    record_decl =
-        llvm::cast<clang::RecordDecl>(ClangUtil::GetAsTagDecl(record_type));
+    record_decl = llvm::cast<clang::RecordDecl>(ClangUtil::GetAsTagDecl(record_type)->getDefinition());
+    fwd_decl = record_decl->getPreviousDecl();
     field_decl = *record_decl->fields().begin();
     assert(field_decl);
   }
 };
 
 } // namespace clang_utils
 } // namespace lldb_private
 
 #endif