[clang] Move accessors for OrigEntry and Filename to FileInfo NFC

[benlangmuir]

Summary

Refactor ContentCache::OrigEntry and Filename to be private and only
expose them from FileInfo. This is in preparation for removing these
fields from ContentCache.

clang/include/clang/Basic/SourceManager.h

 /// One instance of this struct is kept for every file loaded or used.
 ///
 /// This object owns the MemoryBuffer object.
 class alignas(8) ContentCache {
   /// The actual buffer containing the characters from the input
   /// file.
   mutable std::unique_ptr<llvm::MemoryBuffer> Buffer;
 
-public:
+  friend class FileInfo;
+
   /// Reference to the file entry representing this ContentCache.
   ///
   /// This reference does not own the FileEntry object.
   ///
   /// It is possible for this to be NULL if the ContentCache encapsulates
   /// an imaginary text buffer.
   ///
   /// FIXME: Make non-optional using a virtual file as needed, remove \c
   /// Filename and use \c OrigEntry.getNameAsRequested() instead.
   OptionalFileEntryRefDegradesToFileEntryPtr OrigEntry;
 
+  /// The filename that is used to access OrigEntry.
+  ///
+  /// FIXME: Remove this once OrigEntry is a FileEntryRef with a stable name.
+  StringRef Filename;
+
+public:
   /// References the file which the contents were actually loaded from.
   ///
   /// Can be different from 'Entry' if we overridden the contents of one file
   /// with the contents of another file.
   const FileEntry *ContentsEntry;
 
-  /// The filename that is used to access OrigEntry.
-  ///
-  /// FIXME: Remove this once OrigEntry is a FileEntryRef with a stable name.
-  StringRef Filename;
-
   /// A bump pointer allocated array of offsets for each source line.
   ///
   /// This is lazily computed.  The lines are owned by the SourceManager
   /// BumpPointerAllocator object.
   mutable LineOffsetMapping SourceLineCache;
 
   /// Indicates whether the buffer itself was provided to override
   /// the actual file contents.
ContentCache()
         IsFileVolatile(false), IsTransient(false), IsBufferInvalid(false) {}
 
   ContentCache(FileEntryRef Ent) : ContentCache(Ent, Ent) {}
 
   ContentCache(FileEntryRef Ent, const FileEntry *contentEnt)
       : OrigEntry(Ent), ContentsEntry(contentEnt), BufferOverridden(false),
         IsFileVolatile(false), IsTransient(false), IsBufferInvalid(false) {}
 
-  /// The copy ctor does not allow copies where source object has either
-  /// a non-NULL Buffer or SourceLineCache.  Ownership of allocated memory
-  /// is not transferred, so this is a logical error.
-  ContentCache(const ContentCache &RHS)
-      : BufferOverridden(false), IsFileVolatile(false), IsTransient(false),
-        IsBufferInvalid(false) {
-    OrigEntry = RHS.OrigEntry;
-    ContentsEntry = RHS.ContentsEntry;
-
-    assert(!RHS.Buffer && !RHS.SourceLineCache &&
-           "Passed ContentCache object cannot own a buffer.");
-  }
+  /// Create a copy of \p Other with an unowned reference to its buffer as if
+  /// set using \c setUnownedBuffer.
+  static ContentCache createUnownedCopy(const ContentCache &Other);
 
+  ContentCache(ContentCache &&RHS) = default;
+  ContentCache(const ContentCache &RHS) = delete;
   ContentCache &operator=(const ContentCache &RHS) = delete;
 
   /// Returns the memory buffer for the associated content.
   ///
   /// \param Diag Object through which diagnostics will be emitted if the
   ///   buffer cannot be retrieved.
   ///
   /// \param Loc If specified, is the location that invalid file diagnostics
public:
 
   /// Set the flag that indicates that this FileID has
   /// line table entries associated with it.
   void setHasLineDirectives() { HasLineDirectives = true; }
 
   /// Returns the name of the file that was used when the file was loaded from
   /// the underlying file system.
   StringRef getName() const { return getContentCache().Filename; }
+
+  OptionalFileEntryRefDegradesToFileEntryPtr getOrigEntry() const {
+    return getContentCache().OrigEntry;
+  }
 };
 
 /// Each ExpansionInfo encodes the expansion location - where
 /// the token was ultimately expanded, and the SpellingLoc - where the actual
 /// character data for the token came from.
 class ExpansionInfo {
   // Really these are all SourceLocations.
 
getBufferOrFake(FileID FID, SourceLocation Loc = SourceLocation()) const {
     if (auto B = getBufferOrNone(FID, Loc))
       return *B;
     return getFakeBufferForRecovery();
   }
 
   /// Returns the FileEntry record for the provided FileID.
   const FileEntry *getFileEntryForID(FileID FID) const {
     if (auto *Entry = getSLocEntryForFile(FID))
-      return Entry->getFile().getContentCache().OrigEntry;
+      return Entry->getFile().getOrigEntry();
     return nullptr;
   }
 
   /// Returns the FileEntryRef for the provided FileID.
   Optional<FileEntryRef> getFileEntryRefForID(FileID FID) const {
     if (auto *Entry = getSLocEntryForFile(FID))
-      return Entry->getFile().getContentCache().OrigEntry;
+      return Entry->getFile().getOrigEntry();
     return None;
   }
 
   /// Returns the filename for the provided FileID, unless it's a built-in
   /// buffer that's not represented by a filename.
   ///
   /// Returns None for non-files and built-in files.
   Optional<StringRef> getNonBuiltinFilenameForID(FileID FID) const;
 
   /// Returns the FileEntry record for the provided SLocEntry.
   const FileEntry *getFileEntryForSLocEntry(const SrcMgr::SLocEntry &sloc) const
   {
-    return sloc.getFile().getContentCache().OrigEntry;
+    return sloc.getFile().getOrigEntry();
   }
 
   /// Return a StringRef to the source buffer data for the
   /// specified FileID.
   ///
   /// \param FID The file ID whose contents will be returned.
   /// \param Invalid If non-NULL, will be set true if an error occurred.
   StringRef getBufferData(FileID FID, bool *Invalid = nullptr) const;

clang/lib/AST/ASTImporter.cpp

if (FromEx.isMacroArgExpansion()) {
       if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd()))
         MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, ExLength,
                                        FromEx.isExpansionTokenRange());
       else
         return ToExLocE.takeError();
     }
     ToID = ToSM.getFileID(MLoc);
   } else {
-    const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
+    const SrcMgr::FileInfo &FI = FromSLoc.getFile();
+    const SrcMgr::ContentCache *Cache = &FI.getContentCache();
 
     if (!IsBuiltin && !Cache->BufferOverridden) {
       // Include location of this file.
       ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
       if (!ToIncludeLoc)
         return ToIncludeLoc.takeError();
 
       // Every FileID that is not the main FileID needs to have a valid include
       // location so that the include chain points to the main FileID. When
       // importing the main FileID (which has no include location), we need to
       // create a fake include location in the main file to keep this property
       // intact.
       SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
       if (FromID == FromSM.getMainFileID())
         ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(ToSM.getMainFileID());
 
-      if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
+      if (FI.getOrigEntry() && FI.getOrigEntry()->getDir()) {
         // FIXME: We probably want to use getVirtualFile(), so we don't hit the
         // disk again
         // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
         // than mmap the files several times.
         auto Entry =
-            ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
+            ToFileManager.getOptionalFileRef(FI.getOrigEntry()->getName());
         // FIXME: The filename may be a virtual name that does probably not
         // point to a valid file and we get no Entry here. In this case try with
         // the memory buffer below.
         if (Entry)
           ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
                                    FromSLoc.getFile().getFileCharacteristic());
       }
     }

clang/lib/Basic/SourceManager.cpp

 
 bool SourceManager::isMainFile(const FileEntry &SourceFile) {
   assert(MainFileID.isValid() && "expected initialized SourceManager");
   if (auto *FE = getFileEntryForID(MainFileID))
     return FE->getUID() == SourceFile.getUID();
   return false;
 }
 
+ContentCache ContentCache::createUnownedCopy(const ContentCache &Other) {
+  ContentCache Clone;
+  Clone.OrigEntry = Other.OrigEntry;
+  Clone.ContentsEntry = Other.ContentsEntry;
+  Clone.BufferOverridden = Other.BufferOverridden;
+  Clone.IsFileVolatile = Other.IsFileVolatile;
+  Clone.IsTransient = Other.IsTransient;
+  Clone.setUnownedBuffer(Other.getBufferIfLoaded());
+  return Clone;
+}
+
 void SourceManager::initializeForReplay(const SourceManager &Old) {
   assert(MainFileID.isInvalid() && "expected uninitialized SourceManager");
 
   auto CloneContentCache = [&](const ContentCache *Cache) -> ContentCache * {
-    auto *Clone = new (ContentCacheAlloc.Allocate<ContentCache>()) ContentCache;
-    Clone->OrigEntry = Cache->OrigEntry;
-    Clone->ContentsEntry = Cache->ContentsEntry;
-    Clone->BufferOverridden = Cache->BufferOverridden;
-    Clone->IsFileVolatile = Cache->IsFileVolatile;
-    Clone->IsTransient = Cache->IsTransient;
-    Clone->setUnownedBuffer(Cache->getBufferIfLoaded());
-    return Clone;
+    return new (ContentCacheAlloc.Allocate<ContentCache>())
+        ContentCache(ContentCache::createUnownedCopy(*Cache));
   };
 
   // Ensure all SLocEntries are loaded from the external source.
   for (unsigned I = 0, N = Old.LoadedSLocEntryTable.size(); I != N; ++I)
     if (!Old.SLocEntryLoaded[I])
       Old.loadSLocEntry(I, nullptr);
 
   // Inherit any content cache data from the old source manager.

 
 void SourceManager::setFileIsTransient(const FileEntry *File) {
   getOrCreateContentCache(File->getLastRef()).IsTransient = true;
 }
 
 Optional<StringRef>
 SourceManager::getNonBuiltinFilenameForID(FileID FID) const {
   if (const SrcMgr::SLocEntry *Entry = getSLocEntryForFile(FID))
-    if (Entry->getFile().getContentCache().OrigEntry)
+    if (Entry->getFile().getOrigEntry())
       return Entry->getFile().getName();
   return None;
 }
 
 StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
   auto B = getBufferDataOrNone(FID);
   if (Invalid)
     *Invalid = !B;
PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
   const SrcMgr::FileInfo &FI = Entry.getFile();
   const SrcMgr::ContentCache *C = &FI.getContentCache();
 
   // To get the source name, first consult the FileEntry (if one exists)
   // before the MemBuffer as this will avoid unnecessarily paging in the
   // MemBuffer.
   FileID FID = LocInfo.first;
   StringRef Filename;
-  if (C->OrigEntry)
-    Filename = C->OrigEntry->getName();
+  if (Optional<FileEntryRef> E = FI.getOrigEntry())
+    Filename = E->getName();
   else if (auto Buffer = C->getBufferOrNone(Diag, getFileManager()))
     Filename = Buffer->getBufferIdentifier();
 
   unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
     return PresumedLoc();
   unsigned ColNo  = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
FileID SourceManager::translateFile(const FileEntry *SourceFile) const {
   // location in the main file.
   if (MainFileID.isValid()) {
     bool Invalid = false;
     const SLocEntry &MainSLoc = getSLocEntry(MainFileID, &Invalid);
     if (Invalid)
       return FileID();
 
     if (MainSLoc.isFile()) {
-      if (MainSLoc.getFile().getContentCache().OrigEntry == SourceFile)
+      if (MainSLoc.getFile().getOrigEntry() == SourceFile)
         return MainFileID;
     }
   }
 
   // The location we're looking for isn't in the main file; look
   // through all of the local source locations.
   for (unsigned I = 0, N = local_sloc_entry_size(); I != N; ++I) {
     const SLocEntry &SLoc = getLocalSLocEntry(I);
-    if (SLoc.isFile() &&
-        SLoc.getFile().getContentCache().OrigEntry == SourceFile)
+    if (SLoc.isFile() && SLoc.getFile().getOrigEntry() == SourceFile)
       return FileID::get(I);
   }
 
   // If that still didn't help, try the modules.
   for (unsigned I = 0, N = loaded_sloc_entry_size(); I != N; ++I) {
     const SLocEntry &SLoc = getLoadedSLocEntry(I);
-    if (SLoc.isFile() &&
-        SLoc.getFile().getContentCache().OrigEntry == SourceFile)
+    if (SLoc.isFile() && SLoc.getFile().getOrigEntry() == SourceFile)
       return FileID::get(-int(I) - 2);
   }
 
   return FileID();
 }
 
 /// Get the source location in \arg FID for the given line:col.
 /// Returns null location if \arg FID is not a file SLocEntry.
auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
     if (Entry.isFile()) {
       auto &FI = Entry.getFile();
       if (FI.NumCreatedFIDs)
         out << "  covers <FileID " << ID << ":" << int(ID + FI.NumCreatedFIDs)
             << ">\n";
       if (FI.getIncludeLoc().isValid())
         out << "  included from " << FI.getIncludeLoc().getOffset() << "\n";
       auto &CC = FI.getContentCache();
-      out << "  for " << (CC.OrigEntry ? CC.OrigEntry->getName() : "<none>")
+      out << "  for "
+          << (FI.getOrigEntry() ? FI.getOrigEntry()->getName() : "<none>")
           << "\n";
       if (CC.BufferOverridden)
         out << "  contents overridden\n";
-      if (CC.ContentsEntry != CC.OrigEntry) {
+      if (CC.ContentsEntry != FI.getOrigEntry()) {
         out << "  contents from "
             << (CC.ContentsEntry ? CC.ContentsEntry->getName() : "<none>")
             << "\n";
       }
     } else {
       auto &EI = Entry.getExpansion();
       out << "  spelling from " << EI.getSpellingLoc().getOffset() << "\n";
       out << "  macro " << (EI.isMacroArgExpansion() ? "arg" : "body")

clang/lib/Serialization/ASTReader.cpp

if (NumFileDecls && ContextObj) {
       assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
       FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
                                                              NumFileDecls));
     }
 
     const SrcMgr::ContentCache &ContentCache =
         SourceMgr.getOrCreateContentCache(*File, isSystem(FileCharacter));
     if (OverriddenBuffer && !ContentCache.BufferOverridden &&
-        ContentCache.ContentsEntry == ContentCache.OrigEntry &&
+        ContentCache.ContentsEntry == FileInfo.getOrigEntry() &&
         !ContentCache.getBufferIfLoaded()) {
       auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
       if (!Buffer)
         return true;
       SourceMgr.overrideFileContents(*File, std::move(Buffer));
     }
 
     break;

clang/lib/Serialization/ASTWriter.cpp

for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
     const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
     assert(&SourceMgr.getSLocEntry(FileID::get(I)) == SLoc);
 
     // We only care about file entries that were not overridden.
     if (!SLoc->isFile())
       continue;
     const SrcMgr::FileInfo &File = SLoc->getFile();
     const SrcMgr::ContentCache *Cache = &File.getContentCache();
-    if (!Cache->OrigEntry)
+    if (!File.getOrigEntry())
       continue;
 
     if (isModuleMap(File.getFileCharacteristic()) &&
         !isSystem(File.getFileCharacteristic()) &&
         !AffectingClangModuleMaps.empty() &&
-        AffectingClangModuleMaps.find(Cache->OrigEntry) ==
+        AffectingClangModuleMaps.find(File.getOrigEntry()) ==
             AffectingClangModuleMaps.end()) {
-      SkippedModuleMaps.insert(Cache->OrigEntry);
+      SkippedModuleMaps.insert(File.getOrigEntry());
       // Do not emit modulemaps that do not affect current module.
       continue;
     }
 
     InputFileEntry Entry;
-    Entry.File = Cache->OrigEntry;
+    Entry.File = File.getOrigEntry();
     Entry.IsSystemFile = isSystem(File.getFileCharacteristic());
     Entry.IsTransient = Cache->IsTransient;
     Entry.BufferOverridden = Cache->BufferOverridden;
     Entry.IsTopLevelModuleMap = isModuleMap(File.getFileCharacteristic()) &&
                                 File.getIncludeLoc().isInvalid();
 
     auto ContentHash = hash_code(-1);
     if (PP->getHeaderSearchInfo()
for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size();
     // Record the offset of this source-location entry.
     uint64_t Offset = Stream.GetCurrentBitNo() - SLocEntryOffsetsBase;
     assert((Offset >> 32) == 0 && "SLocEntry offset too large");
     SLocEntryOffsets.push_back(Offset);
 
     // Figure out which record code to use.
     unsigned Code;
     if (SLoc->isFile()) {
-      const SrcMgr::ContentCache *Cache = &SLoc->getFile().getContentCache();
-      if (Cache->OrigEntry) {
+      if (SLoc->getFile().getOrigEntry()) {
         Code = SM_SLOC_FILE_ENTRY;
       } else
         Code = SM_SLOC_BUFFER_ENTRY;
     } else
       Code = SM_SLOC_EXPANSION_ENTRY;
     Record.clear();
     Record.push_back(Code);
 
     // Starting offset of this entry within this module, so skip the dummy.
     Record.push_back(SLoc->getOffset() - 2);
     if (SLoc->isFile()) {
       const SrcMgr::FileInfo &File = SLoc->getFile();
+      const FileEntry *OrigEntry = File.getOrigEntry();
       const SrcMgr::ContentCache *Content = &File.getContentCache();
-      if (Content->OrigEntry && !SkippedModuleMaps.empty() &&
-          SkippedModuleMaps.find(Content->OrigEntry) !=
-              SkippedModuleMaps.end()) {
+      if (OrigEntry && !SkippedModuleMaps.empty() &&
+          SkippedModuleMaps.find(OrigEntry) != SkippedModuleMaps.end()) {
         // Do not emit files that were not listed as inputs.
         continue;
       }
       AddSourceLocation(File.getIncludeLoc(), Record);
       Record.push_back(File.getFileCharacteristic()); // FIXME: stable encoding
       Record.push_back(File.hasLineDirectives());
 
       bool EmitBlob = false;
-      if (Content->OrigEntry) {
-        assert(Content->OrigEntry == Content->ContentsEntry &&
+      if (OrigEntry) {
+        assert(OrigEntry == Content->ContentsEntry &&
                "Writing to AST an overridden file is not supported");
 
         // The source location entry is a file. Emit input file ID.
-        assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
-        Record.push_back(InputFileIDs[Content->OrigEntry]);
+        assert(InputFileIDs[OrigEntry] != 0 && "Missed file entry");
+        Record.push_back(InputFileIDs[OrigEntry]);
 
         Record.push_back(File.NumCreatedFIDs);
 
         FileDeclIDsTy::iterator FDI = FileDeclIDs.find(FID);
         if (FDI != FileDeclIDs.end()) {
           Record.push_back(FDI->second->FirstDeclIndex);
           Record.push_back(FDI->second->DeclIDs.size());
         } else {

clang/tools/libclang/CIndexInclusionStack.cpp

void getInclusions(bool IsLocal, unsigned n, CXTranslationUnit TU,
   for (unsigned i = 0 ; i < n ; ++i) {
     bool Invalid = false;
     const SrcMgr::SLocEntry &SL =
         IsLocal ? SM.getLocalSLocEntry(i) : SM.getLoadedSLocEntry(i, &Invalid);
     if (!SL.isFile() || Invalid)
       continue;
 
     const SrcMgr::FileInfo &FI = SL.getFile();
-    if (!FI.getContentCache().OrigEntry)
+    if (!FI.getOrigEntry())
       continue;
 
     // If this is the main file, and there is a preamble, skip this SLoc. The
     // inclusions of the preamble already showed it.
     SourceLocation L = FI.getIncludeLoc();
     if (HasPreamble && CXXUnit->isInMainFileID(L))
       continue;
 
     // Build the inclusion stack.
     InclusionStack.clear();
     while (L.isValid()) {
       PresumedLoc PLoc = SM.getPresumedLoc(L);
       InclusionStack.push_back(cxloc::translateSourceLocation(Ctx, L));
       L = PLoc.isValid()? PLoc.getIncludeLoc() : SourceLocation();
     }
 
     // If there is a preamble, the last entry is the "inclusion" of that
     // preamble into the main file, which has the bogus entry of main.c:1:1
     if (HasPreamble && !InclusionStack.empty())
       InclusionStack.pop_back();
 
     // Callback to the client.
     // FIXME: We should have a function to construct CXFiles.
     CB(static_cast<CXFile>(const_cast<FileEntry *>(
-           static_cast<const FileEntry *>(FI.getContentCache().OrigEntry))),
+           static_cast<const FileEntry *>(FI.getOrigEntry()))),
        InclusionStack.data(), InclusionStack.size(), clientData);
   }
 }
 } // namespace
 
 void clang_getInclusions(CXTranslationUnit TU, CXInclusionVisitor CB,
                          CXClientData clientData) {
   if (cxtu::isNotUsableTU(TU)) {