[DO NOT MERGE][Testing] Review Clang patches

interpreter/cling/lib/Interpreter/ClangInternalState.cpp

@@ -274,14 +274,14 @@ namespace cling {
           // There is content - a memory buffer or a file.
           // We know it's a file because we started off the FileEntry.
 
-          // FIXME: LLVM will completely migrate to FileEntryRef.
-          // We added `isOpen()` in our commit:
-          // `Accessor to "is file opened"; this is crucial info for us.`
-          // Move this logic to FileEntryRef or have a workaround.
-          if (FE.getFileEntry().isOpen())
-            ParsedOpen.emplace_back(std::move(fileName));
-          else
-            Parsed.emplace_back(std::move(fileName));
+          // // FIXME: LLVM will completely migrate to FileEntryRef.
+          // // We added `isOpen()` in our commit:
+          // // `Accessor to "is file opened"; this is crucial info for us.`
+          // // Move this logic to FileEntryRef or have a workaround.
+          // if (FE.getFileEntry().isOpen())
+          //   ParsedOpen.emplace_back(std::move(fileName));
+          // else
+          //   Parsed.emplace_back(std::move(fileName));
         } else
          AST.emplace_back(std::move(fileName));
       }

interpreter/cling/lib/Interpreter/DeclUnloader.cpp

@@ -493,12 +493,12 @@ namespace cling {
   }
 
   DeclUnloader::~DeclUnloader() {
-    SourceManager& SM = m_Sema->getSourceManager();
-    for (FileIDs::iterator I = m_FilesToUncache.begin(),
-           E = m_FilesToUncache.end(); I != E; ++I) {
-      // We need to reset the cache
-      SM.invalidateCache(*I);
-    }
+    // SourceManager& SM = m_Sema->getSourceManager();
+    // for (FileIDs::iterator I = m_FilesToUncache.begin(),
+    //        E = m_FilesToUncache.end(); I != E; ++I) {
+    //   // We need to reset the cache
+    //   SM.invalidateCache(*I);
+    // }
   }
 
   void DeclUnloader::CollectFilesToUncache(SourceLocation Loc) {
@@ -1024,8 +1024,8 @@ namespace cling {
     bool Successful = true;
 
     // Remove specializations, but do not invalidate the iterator!
-    for (FunctionTemplateDecl::spec_iterator I = FTD->loaded_spec_begin(),
-           E = FTD->loaded_spec_end(); I != E; ++I)
+    for (FunctionTemplateDecl::spec_iterator I = FTD->spec_begin(),
+           E = FTD->spec_end(); I != E; ++I)
       Successful &= VisitFunctionDecl(*I, /*RemoveSpec=*/false);
 
     Successful &= VisitRedeclarableTemplateDecl(FTD);
@@ -1036,9 +1036,9 @@ namespace cling {
   bool DeclUnloader::VisitClassTemplateDecl(ClassTemplateDecl* CTD) {
     // ClassTemplateDecl: TemplateDecl, Redeclarable
     bool Successful = true;
-    // Remove specializations, but do not invalidate the iterator!
-    for (ClassTemplateDecl::spec_iterator I = CTD->loaded_spec_begin(),
-           E = CTD->loaded_spec_end(); I != E; ++I)
+    // Remove specializations:
+    for (ClassTemplateDecl::spec_iterator I = CTD->spec_begin(),
+           E = CTD->spec_end(); I != E; ++I)
       Successful &=
           VisitClassTemplateSpecializationDecl(*I, /*RemoveSpec=*/false);
 
@@ -1082,8 +1082,8 @@ namespace cling {
     // VarTemplateDecl: TemplateDecl, Redeclarable
     bool Successful = true;
     // Remove specializations, but do not invalidate the iterator!
-    for (VarTemplateDecl::spec_iterator I = VTD->loaded_spec_begin(),
-                                        E = VTD->loaded_spec_end();
+    for (VarTemplateDecl::spec_iterator I = VTD->spec_begin(),
+                                        E = VTD->spec_end();
          I != E; ++I)
       Successful &=
           VisitVarTemplateSpecializationDecl(*I, /*RemoveSpec=*/false);

interpreter/cling/lib/Interpreter/TransactionUnloader.cpp

@@ -161,9 +161,9 @@ namespace cling {
     else
       T->setState(Transaction::kRolledBackWithErrors);
 
-    // Release the input_line_X file unless verifying diagnostics.
-    if (!m_Interp->getCI()->getDiagnosticOpts().VerifyDiagnostics)
-      m_Sema->getSourceManager().invalidateCache(T->getBufferFID());
+    // // Release the input_line_X file unless verifying diagnostics.
+    // if (!m_Interp->getCI()->getDiagnosticOpts().VerifyDiagnostics)
+    //   m_Sema->getSourceManager().invalidateCache(T->getBufferFID());
 
     return Successful;
   }

interpreter/llvm-project/clang/include/clang/AST/DeclTemplate.h

@@ -1085,20 +1085,6 @@ class FunctionTemplateDecl : public RedeclarableTemplateDecl {
     return makeSpecIterator(getSpecializations(), true);
   }
 
-  /// All specializations that that have already been loaded, ie avoiding
-  /// deserialization of lazily registered specializations.
-  spec_range loaded_specializations() const {
-    return spec_range(loaded_spec_begin(), loaded_spec_end());
-  }
-
-  spec_iterator loaded_spec_begin() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, false);
-  }
-
-  spec_iterator loaded_spec_end() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, true);
-  }
-
   /// Return whether this function template is an abbreviated function template,
   /// e.g. `void foo(auto x)` or `template<typename T> void foo(auto x)`
   bool isAbbreviated() const {
@@ -2468,20 +2454,6 @@ class ClassTemplateDecl : public RedeclarableTemplateDecl {
     return makeSpecIterator(getSpecializations(), true);
   }
 
-  /// All specializations that that have already been loaded, ie avoiding
-  /// deserialization of lazily registered specializations.
-  spec_range loaded_specializations() const {
-    return spec_range(loaded_spec_begin(), loaded_spec_end());
-  }
-
-  spec_iterator loaded_spec_begin() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, false);
-  }
-
-  spec_iterator loaded_spec_end() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, true);
-  }
-
   // Implement isa/cast/dyncast support
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ClassTemplate; }
@@ -3210,20 +3182,6 @@ class VarTemplateDecl : public RedeclarableTemplateDecl {
     return makeSpecIterator(getSpecializations(), true);
   }
 
-  /// All specializations that that have already been loaded, ie avoiding
-  /// deserialization of lazily registered specializations.
-  spec_range loaded_specializations() const {
-    return spec_range(loaded_spec_begin(), loaded_spec_end());
-  }
-
-  spec_iterator loaded_spec_begin() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, false);
-  }
-
-  spec_iterator loaded_spec_end() const {
-    return makeSpecIterator(getCommonPtr()->Specializations, true);
-  }
-
   // Implement isa/cast/dyncast support
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == VarTemplate; }

interpreter/llvm-project/clang/include/clang/Basic/FileEntry.h

@@ -327,7 +327,6 @@ class FileEntry {
   ~FileEntry();
 
   StringRef tryGetRealPathName() const { return RealPathName; }
-  bool isOpen() const { return (bool)File; }
   off_t getSize() const { return Size; }
   // Size may increase due to potential z/OS EBCDIC -> UTF-8 conversion.
   void setSize(off_t NewSize) { Size = NewSize; }

interpreter/llvm-project/clang/include/clang/Basic/FileManager.h

@@ -32,7 +32,6 @@
 #include <map>
 #include <memory>
 #include <string>
-#include <set>
 
 namespace llvm {
 
@@ -108,11 +107,6 @@ class FileManager : public RefCountedBase<FileManager> {
   /// The canonical names of files and directories .
   llvm::DenseMap<const void *, llvm::StringRef> CanonicalNames;
 
-  std::set<const FileEntry*> FileEntriesToReread;
-
-  /// The canonical names of directories.
-  llvm::DenseMap<const DirectoryEntry *, llvm::StringRef> CanonicalDirNames;
-
   /// Storage for canonical names that we have computed.
   llvm::BumpPtrAllocator CanonicalNameStorage;
 
@@ -332,9 +326,6 @@ class FileManager : public RefCountedBase<FileManager> {
   std::error_code getNoncachedStatValue(StringRef Path,
                                         llvm::vfs::Status &Result);
 
-  /// Remove the real file \p Entry from the cache.
-  void invalidateCache(FileEntryRef Entry);
-
   /// If path is not absolute and FileSystemOptions set the working
   /// directory, the path is modified to be relative to the given
   /// working directory.

interpreter/llvm-project/clang/include/clang/Basic/SourceManager.h

@@ -256,7 +256,7 @@ class alignas(8) ContentCache {
 
   /// Set the buffer.
   void setBuffer(std::unique_ptr<llvm::MemoryBuffer> B) {
-    IsBufferInvalid = !B;
+    IsBufferInvalid = false;
     Buffer = std::move(B);
   }
 
@@ -845,8 +845,6 @@ class SourceManager : public RefCountedBase<SourceManager> {
 
   void clearIDTables();
 
-  void invalidateCache(FileID FID);
-
   /// Initialize this source manager suitably to replay the compilation
   /// described by \p Old. Requires that \p Old outlive \p *this.
   void initializeForReplay(const SourceManager &Old);

interpreter/llvm-project/clang/include/clang/Sema/Sema.h

@@ -2732,7 +2732,7 @@ class Sema final : public SemaBase {
 
 public:
   // Marks SS invalid if it represents an incomplete type.
-  bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *&DC);
+  bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
   // Complete an enum decl, maybe without a scope spec.
   bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L,
                                CXXScopeSpec *SS = nullptr);
@@ -11344,8 +11344,8 @@ class Sema final : public SemaBase {
   bool CheckTemplateParameterList(TemplateParameterList *NewParams,
                                   TemplateParameterList *OldParams,
                                   TemplateParamListContext TPC,
-                                  SkipBodyInfo *SkipBody = nullptr,
-                                  bool Complain = true);
+                                  SkipBodyInfo *SkipBody = nullptr);
+
   /// Match the given template parameter lists to the given scope
   /// specifier, returning the template parameter list that applies to the
   /// name.

interpreter/llvm-project/clang/include/clang/Serialization/ASTReader.h

@@ -757,9 +757,6 @@ class ASTReader
   /// files.
   llvm::DenseSet<LoadedMacroInfo> LoadedUndefs;
 
-  /// \Token literal data loaded and owned by us.
-  std::vector<std::string *> TokenLiteralDataLoaded;
-
   using GlobalMacroMapType =
       ContinuousRangeMap<serialization::MacroID, ModuleFile *, 4>;
 

interpreter/llvm-project/clang/lib/AST/ASTImporter.cpp

@@ -10080,7 +10080,7 @@ Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
       // FIXME: We want to re-use the existing MemoryBuffer!
       std::optional<llvm::MemoryBufferRef> FromBuf =
           Cache->getBufferOrNone(FromContext.getDiagnostics(),
-                                 FromFileManager, SourceLocation{});
+                                 FromSM.getFileManager(), SourceLocation{});
       if (!FromBuf)
         return llvm::make_error<ASTImportError>(ASTImportError::Unknown);
 

interpreter/llvm-project/clang/lib/AST/DeclTemplate.cpp

@@ -367,6 +367,12 @@ bool RedeclarableTemplateDecl::loadLazySpecializationsImpl(
   if (!ExternalSource)
     return false;
 
+  // If TPL is not null, it implies that we're loading specializations for
+  // partial templates. We need to load all specializations in such cases.
+  if (TPL)
+    return ExternalSource->LoadExternalSpecializations(this->getCanonicalDecl(),
+                                                       /*OnlyPartial=*/false);
+
   return ExternalSource->LoadExternalSpecializations(this->getCanonicalDecl(),
                                                      Args);
 }

interpreter/llvm-project/clang/lib/AST/TemplateBase.cpp

@@ -130,14 +130,8 @@ static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out,
     } else
       Out << "(" << T->getCanonicalTypeInternal().getAsString(Policy) << ")"
           << Val;
-  } else {
+  } else
     Out << Val;
-    // Handle cases where the value is too large to fit into the underlying type
-    // i.e. where the unsignedness matters.
-    if (T->isBuiltinType())
-      if (Val.isUnsigned() && Val.getBitWidth() == 64 && Val.countLeadingOnes())
-        Out << "ull";
-  }
 }
 
 static unsigned getArrayDepth(QualType type) {

interpreter/llvm-project/clang/lib/Basic/Diagnostic.cpp

@@ -183,29 +183,7 @@ void DiagnosticsEngine::DiagStateMap::append(SourceManager &SrcMgr,
        Offset = F->ParentOffset, F = F->Parent) {
     F->HasLocalTransitions = true;
     auto &Last = F->StateTransitions.back();
-    if (Last.Offset > Offset) {
-      // Deal with a state change induce by recursive parsing.  The first parsing is
-      // suspended and a (recursive) parsing is started between associated (in the upper/outer
-      // file) with a newer line (hence greater offset).  After the end of the recursive
-      // parsing, we go back to the first parsing and any state change will done 'earlier'
-      // and trigger:
-      //   assert(Last.Offset <= Offset && "state transitions added out of order");
-      auto OnePastIt = std::upper_bound(
-        F->StateTransitions.begin(), F->StateTransitions.end(), Offset,
-        [](unsigned Offset, const DiagStatePoint &P) {
-          return Offset < P.Offset;
-        });
-      if (OnePastIt == F->StateTransitions.begin() || (OnePastIt[-1].Offset != Offset)) {
-        F->StateTransitions.insert( OnePastIt, {State, Offset});
-      } else {
-        auto &Prev = OnePastIt[-1];
-        if (Prev.State == State)
-          break;
-        Prev.State = State;
-        continue;
-      }
-      continue;
-    }
+    assert(Last.Offset <= Offset && "state transitions added out of order");
 
     if (Last.Offset == Offset) {
       if (Last.State == State)

interpreter/llvm-project/clang/lib/Basic/FileManager.cpp

@@ -221,25 +221,7 @@ llvm::Expected<FileEntryRef> FileManager::getFileRef(StringRef Filename,
   // See if there is already an entry in the map.
   auto SeenFileInsertResult =
       SeenFileEntries.insert({Filename, std::errc::no_such_file_or_directory});
-
-  auto *NamedFileEnt = &*SeenFileInsertResult.first;
-
-  const FileEntry *StaleFileEntry = 0;
-  bool needsRereading = false;
-  if (NamedFileEnt && NamedFileEnt->getValue()) {
-    FileEntryRef::MapValue Value = *NamedFileEnt->getValue();
-    if (Value.V.is<FileEntry *>()) {
-      auto found = FileEntriesToReread.find(Value.V.get<FileEntry*>());
-      if (found != FileEntriesToReread.end()) {
-        needsRereading = true;
-        StaleFileEntry = *found;
-        FileEntriesToReread.erase(found);
-      }
-    }
-  }
-
-  // See if there is already an entry in the map.
-  if (!SeenFileInsertResult.second && !needsRereading) {
+  if (!SeenFileInsertResult.second) {
     if (!SeenFileInsertResult.first->second)
       return llvm::errorCodeToError(
           SeenFileInsertResult.first->second.getError());
@@ -248,6 +230,8 @@ llvm::Expected<FileEntryRef> FileManager::getFileRef(StringRef Filename,
 
   // We've not seen this before. Fill it in.
   ++NumFileCacheMisses;
+  auto *NamedFileEnt = &*SeenFileInsertResult.first;
+  assert(!NamedFileEnt->second && "should be newly-created");
 
   // Get the null-terminated file name as stored as the key of the
   // SeenFileEntries map.
@@ -351,9 +335,7 @@ llvm::Expected<FileEntryRef> FileManager::getFileRef(StringRef Filename,
   }
 
   FileEntryRef ReturnedRef(*NamedFileEnt);
-  if (ReusingEntry &&
-      llvm::sys::toTimeT(Status.getLastModificationTime()) == UFE->ModTime) {
-    // Already have an entry with this inode, return it.
+  if (ReusingEntry) { // Already have an entry with this inode, return it.
     return ReturnedRef;
   }
 
@@ -373,20 +355,6 @@ llvm::Expected<FileEntryRef> FileManager::getFileRef(StringRef Filename,
     // We should still fill the path even if we aren't opening the file.
     fillRealPathName(UFE, InterndFileName);
   }
-
-  if (StaleFileEntry) {
-    // Find occurrences of old FileEntry; update with new one:
-    for (auto& fe: SeenFileEntries) {
-      if (fe.getValue()) {
-        FileEntryRef::MapValue Value = *fe.getValue();
-        if (Value.V.is<FileEntry *>()
-            && Value.V.get<FileEntry*>() == StaleFileEntry) {
-          fe.setValue(FileEntryRef::MapValue(*UFE, DirInfo));
-        }
-      }
-    }
-  }
-
   return ReturnedRef;
 }
 
@@ -645,11 +613,6 @@ FileManager::getNoncachedStatValue(StringRef Path,
   return std::error_code();
 }
 
-void FileManager::invalidateCache(FileEntryRef Entry) {
-  assert(Entry && "Cannot invalidate a NULL FileEntry");
-  FileEntriesToReread.insert(Entry);
-}
-
 void FileManager::GetUniqueIDMapping(
     SmallVectorImpl<OptionalFileEntryRef> &UIDToFiles) const {
   UIDToFiles.clear();