[clang][modules] Only update the generation number if the update was not delayed.

Author: mpark

clang/include/clang/AST/ASTContext.h

@@ -3730,7 +3730,7 @@ inline void operator delete[](void *Ptr, const clang::ASTContext &C, size_t) {
 
 /// Create the representation of a LazyGenerationalUpdatePtr.
 template <typename Owner, typename T,
-          void (clang::ExternalASTSource::*Update)(Owner)>
+          bool (clang::ExternalASTSource::*Update)(Owner)>
 typename clang::LazyGenerationalUpdatePtr<Owner, T, Update>::ValueType
     clang::LazyGenerationalUpdatePtr<Owner, T, Update>::makeValue(
         const clang::ASTContext &Ctx, T Value) {

clang/include/clang/AST/ExternalASTSource.h

@@ -220,8 +220,9 @@ class ExternalASTSource : public RefCountedBase<ExternalASTSource> {
   /// Gives the external AST source an opportunity to complete
   /// the redeclaration chain for a declaration. Called each time we
   /// need the most recent declaration of a declaration after the
-  /// generation count is incremented.
-  virtual void CompleteRedeclChain(const Decl *D);
+  /// generation count is incremented. Returns true if the redeclaration
+  /// chain completion was completed.
+  virtual bool CompleteRedeclChain(const Decl *D);
 
   /// Gives the external AST source an opportunity to complete
   /// an incomplete type.
@@ -437,7 +438,7 @@ struct LazyOffsetPtr {
 /// A lazy value (of type T) that is within an AST node of type Owner,
 /// where the value might change in later generations of the external AST
 /// source.
-template<typename Owner, typename T, void (ExternalASTSource::*Update)(Owner)>
+template<typename Owner, typename T, bool (ExternalASTSource::*Update)(Owner)>
 struct LazyGenerationalUpdatePtr {
   /// A cache of the value of this pointer, in the most recent generation in
   /// which we queried it.
@@ -487,9 +488,9 @@ struct LazyGenerationalUpdatePtr {
   /// Get the value of this pointer, updating its owner if necessary.
   T get(Owner O) {
     if (auto *LazyVal = Value.template dyn_cast<LazyData *>()) {
-      if (LazyVal->LastGeneration != LazyVal->ExternalSource->getGeneration()) {
+      if (LazyVal->LastGeneration != LazyVal->ExternalSource->getGeneration() &&
+          (LazyVal->ExternalSource->*Update)(O)) {
         LazyVal->LastGeneration = LazyVal->ExternalSource->getGeneration();
-        (LazyVal->ExternalSource->*Update)(O);
       }
       return LazyVal->LastValue;
     }
@@ -516,7 +517,7 @@ namespace llvm {
 /// Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be
 /// placed into a PointerUnion.
 template<typename Owner, typename T,
-         void (clang::ExternalASTSource::*Update)(Owner)>
+         bool (clang::ExternalASTSource::*Update)(Owner)>
 struct PointerLikeTypeTraits<
     clang::LazyGenerationalUpdatePtr<Owner, T, Update>> {
   using Ptr = clang::LazyGenerationalUpdatePtr<Owner, T, Update>;

clang/include/clang/Sema/MultiplexExternalSemaSource.h

@@ -69,7 +69,7 @@ class MultiplexExternalSemaSource : public ExternalSemaSource {
 
   /// Complete the redeclaration chain if it's been extended since the
   /// previous generation of the AST source.
-  void CompleteRedeclChain(const Decl *D) override;
+  bool CompleteRedeclChain(const Decl *D) override;
 
   /// Resolve a selector ID into a selector.
   Selector GetExternalSelector(uint32_t ID) override;

clang/include/clang/Serialization/ASTReader.h

@@ -1226,7 +1226,7 @@ class ASTReader
 
   /// The list of canonical declarations whose redeclaration chains
   /// need to be marked as incomplete once we're done deserializing things.
-  SmallVector<Decl *, 16> PendingIncompleteDeclChains;
+  llvm::SmallPtrSet<Decl *, 16> PendingIncompleteDeclChains;
 
   /// The Decl IDs for the Sema/Lexical DeclContext of a Decl that has
   /// been loaded but its DeclContext was not set yet.
@@ -2135,7 +2135,7 @@ class ASTReader
   /// If any redeclarations of \p D have been imported since it was
   /// last checked, this digs out those redeclarations and adds them to the
   /// redeclaration chain for \p D.
-  void CompleteRedeclChain(const Decl *D) override;
+  bool CompleteRedeclChain(const Decl *D) override;
 
   CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override;
 

clang/lib/AST/ExternalASTSource.cpp

@@ -42,7 +42,7 @@ void ExternalASTSource::FindFileRegionDecls(FileID File, unsigned Offset,
                                             unsigned Length,
                                             SmallVectorImpl<Decl *> &Decls) {}
 
-void ExternalASTSource::CompleteRedeclChain(const Decl *D) {}
+bool ExternalASTSource::CompleteRedeclChain(const Decl *D) { return true; }
 
 void ExternalASTSource::CompleteType(TagDecl *Tag) {}
 

clang/lib/Sema/MultiplexExternalSemaSource.cpp

@@ -53,9 +53,11 @@ Decl *MultiplexExternalSemaSource::GetExternalDecl(GlobalDeclID ID) {
   return nullptr;
 }
 
-void MultiplexExternalSemaSource::CompleteRedeclChain(const Decl *D) {
-  for (size_t i = 0; i < Sources.size(); ++i)
-    Sources[i]->CompleteRedeclChain(D);
+bool MultiplexExternalSemaSource::CompleteRedeclChain(const Decl *D) {
+  bool Result = true;
+  for (ExternalSemaSource *Source : Sources)
+    Result &= Source->CompleteRedeclChain(D);
+  return Result;
 }
 
 Selector MultiplexExternalSemaSource::GetExternalSelector(uint32_t ID) {

clang/lib/Serialization/ASTReader.cpp

@@ -7825,19 +7825,19 @@ ASTRecordReader::readASTTemplateArgumentListInfo() {
 
 Decl *ASTReader::GetExternalDecl(GlobalDeclID ID) { return GetDecl(ID); }
 
-void ASTReader::CompleteRedeclChain(const Decl *D) {
+bool ASTReader::CompleteRedeclChain(const Decl *D) {
   if (NumCurrentElementsDeserializing) {
     // We arrange to not care about the complete redeclaration chain while we're
     // deserializing. Just remember that the AST has marked this one as complete
     // but that it's not actually complete yet, so we know we still need to
     // complete it later.
-    PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
-    return;
+    PendingIncompleteDeclChains.insert(const_cast<Decl*>(D));
+    return false;
   }
 
   if (!D->getDeclContext()) {
     assert(isa<TranslationUnitDecl>(D) && "Not a TU?");
-    return;
+    return true;
   }
 
   const DeclContext *DC = D->getDeclContext()->getRedeclContext();
@@ -7894,6 +7894,8 @@ void ASTReader::CompleteRedeclChain(const Decl *D) {
     else
       Template->loadLazySpecializationsImpl(Args);
   }
+
+  return true;
 }
 
 CXXCtorInitializer **
@@ -10233,8 +10235,8 @@ void ASTReader::finishPendingActions() {
 
     // For each decl chain that we wanted to complete while deserializing, mark
     // it as "still needs to be completed".
-    for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
-      markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
+    for (Decl* D : PendingIncompleteDeclChains) {
+      markIncompleteDeclChain(D);
     }
     PendingIncompleteDeclChains.clear();
 

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

@@ -117,8 +117,8 @@ class ExternalASTSourceWrapper : public clang::ExternalSemaSource {
     m_Source->FindFileRegionDecls(File, Offset, Length, Decls);
   }
 
-  void CompleteRedeclChain(const clang::Decl *D) override {
-    m_Source->CompleteRedeclChain(D);
+  bool CompleteRedeclChain(const clang::Decl *D) override {
+    return m_Source->CompleteRedeclChain(D);
   }
 
   void CompleteType(clang::TagDecl *Tag) override {
@@ -334,9 +334,11 @@ class SemaSourceWithPriorities : public clang::ExternalSemaSource {
     return newDeclFound;
   }
 
-  void CompleteRedeclChain(const clang::Decl *D) override {
-    for (size_t i = 0; i < Sources.size(); ++i)
-      Sources[i]->CompleteRedeclChain(D);
+  bool CompleteRedeclChain(const clang::Decl *D) override {
+    bool Result = true;
+    for (clang::ExternalSemaSource *Source : Sources)
+      Result &= Source->CompleteRedeclChain(D);
+    return Result;
   }
 
   clang::Selector GetExternalSelector(uint32_t ID) override {