[Serialization] Serialize fingerprint, mtime, size of the source files

Author: rintaro

include/swift/AST/FileUnit.h

@@ -402,8 +402,8 @@ class LoadedFile : public FileUnit {
     return false;
   }
 
-  virtual void
-  collectSourceFileNames(llvm::function_ref<void(StringRef)> callback) const {}
+  virtual void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const {}
 
   static bool classof(const FileUnit *file) {
     return file->getKind() == FileUnitKind::SerializedAST ||

include/swift/AST/Module.h

@@ -728,7 +728,8 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return ReverseFullNameIterator(this);
   }
 
-  void collectSourceFileNames(llvm::function_ref<void(StringRef)> callback);
+  void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback);
 
   SourceRange getSourceRange() const { return SourceRange(); }
 

include/swift/AST/RawComment.h

@@ -13,11 +13,15 @@
 #ifndef SWIFT_AST_RAW_COMMENT_H
 #define SWIFT_AST_RAW_COMMENT_H
 
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/SourceManager.h"
 
 namespace swift {
+
+class SourceFile;
+
 struct SingleRawComment {
   enum class CommentKind {
     OrdinaryLine,  ///< Any normal // comments
@@ -92,6 +96,17 @@ struct BasicDeclLocs {
   LineColumn EndLoc;
 };
 
+struct BasicSourceFileInfo {
+  StringRef FilePath;
+  Fingerprint InterfaceHash = Fingerprint::ZERO();
+  llvm::sys::TimePoint<> LastModified = {};
+  uint64_t FileSize = 0;
+
+  BasicSourceFileInfo() {}
+
+  bool populate(SourceFile *SF);
+};
+
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_RAW_COMMENT_H

include/swift/Serialization/SerializedModuleLoader.h

@@ -446,8 +446,8 @@ class SerializedASTFile final : public LoadedFile {
 
   StringRef getTargetTriple() const;
 
-  virtual void collectSourceFileNames(
-      llvm::function_ref<void(StringRef)>) const override;
+  virtual void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)>) const override;
 
   static bool classof(const FileUnit *file) {
     return file->getKind() == FileUnitKind::SerializedAST;

lib/AST/Module.cpp

@@ -1538,13 +1538,16 @@ const clang::Module *ModuleDecl::findUnderlyingClangModule() const {
   return nullptr;
 }
 
-void ModuleDecl::collectSourceFileNames(
-    llvm::function_ref<void(StringRef)> callback) {
+void ModuleDecl::collectBasicSourceFileInfo(
+    llvm::function_ref<void(const BasicSourceFileInfo &)> callback) {
   for (FileUnit *fileUnit : getFiles()) {
     if (SourceFile *SF = dyn_cast<SourceFile>(fileUnit)) {
-      callback(SF->getFilename());
+      BasicSourceFileInfo info;
+      if (info.populate(SF))
+        continue;
+      callback(info);
     } else if (auto *serialized = dyn_cast<LoadedFile>(fileUnit)) {
-      serialized->collectSourceFileNames(callback);
+      serialized->collectBasicSourceFileInfo(callback);
     }
   }
 }

lib/AST/RawComment.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/PrettyStackTrace.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/PrimitiveParsing.h"
 #include "swift/Basic/SourceManager.h"
@@ -238,3 +239,27 @@ CharSourceRange RawComment::getCharSourceRange() {
                 static_cast<const char *>(Start.getOpaquePointerValue());
   return CharSourceRange(Start, Length);
 }
+
+bool BasicSourceFileInfo::populate(SourceFile *SF) {
+  SourceManager &SM = SF->getASTContext().SourceMgr;
+
+  auto filename = SF->getFilename();
+  if (filename.empty())
+    return true;
+  auto stat = SM.getFileSystem()->status(filename);
+  if (!stat)
+    return true;
+
+  FilePath = filename;
+  LastModified = stat->getLastModificationTime();
+  FileSize = stat->getSize();
+
+  if (SF->hasInterfaceHash()) {
+    InterfaceHash = SF->getInterfaceHashIncludingTypeMembers();
+  } else {
+    // FIXME: Parse the file with EnableInterfaceHash option.
+    InterfaceHash = Fingerprint::ZERO();
+  }
+
+  return false;
+}

lib/Serialization/ModuleFile.cpp

@@ -959,8 +959,8 @@ Optional<CommentInfo> ModuleFile::getCommentForDecl(const Decl *D) const {
   return getCommentForDeclByUSR(USRBuffer.str());
 }
 
-void ModuleFile::collectSourceFileNames(
-    llvm::function_ref<void(StringRef)> callback) const {
+void ModuleFile::collectBasicSourceFileInfo(
+    llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const {
   if (Core->SourceFileListData.empty())
     return;
   assert(!Core->SourceLocsTextData.empty());
@@ -969,11 +969,23 @@ void ModuleFile::collectSourceFileNames(
   auto *End = Core->SourceFileListData.bytes_end();
   while (Cursor < End) {
     auto fileID = endian::readNext<uint32_t, little, unaligned>(Cursor);
+    auto fpStr = StringRef{reinterpret_cast<const char *>(Cursor),
+                           Fingerprint::DIGEST_LENGTH};
+    Cursor += Fingerprint::DIGEST_LENGTH;
+    auto timestamp = endian::readNext<uint64_t, little, unaligned>(Cursor);
+    auto fileSize = endian::readNext<uint64_t, little, unaligned>(Cursor);
+
     assert(fileID < Core->SourceLocsTextData.size());
     auto filePath = Core->SourceLocsTextData.substr(fileID);
     size_t terminatorOffset = filePath.find('\0');
     filePath = filePath.slice(0, terminatorOffset);
-    callback(filePath);
+
+    BasicSourceFileInfo info;
+    info.FilePath = filePath;
+    info.InterfaceHash = Fingerprint::fromString(fpStr);
+    info.LastModified = llvm::sys::TimePoint<>(std::chrono::seconds(timestamp));
+    info.FileSize = fileSize;
+    callback(info);
   }
 }
 

lib/Serialization/ModuleFile.h

@@ -694,7 +694,8 @@ class ModuleFile
   Optional<BasicDeclLocs> getBasicDeclLocsForDecl(const Decl *D) const;
   Identifier getDiscriminatorForPrivateValue(const ValueDecl *D);
   Optional<Fingerprint> loadFingerprint(const IterableDeclContext *IDC) const;
-  void collectSourceFileNames(llvm::function_ref<void(StringRef)> callback) const;
+  void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const;
 
 
   // MARK: Deserialization interface

lib/Serialization/SerializeDoc.cpp

@@ -793,29 +793,39 @@ static void emitFileListRecord(llvm::BitstreamWriter &Out,
     llvm::SmallString<1024> Buffer;
     llvm::StringSet<> seenFilenames;
 
-    void emitFilename(StringRef filename) {
-      if (filename.empty())
-        return;
-      llvm::SmallString<128> absolutePath = filename;
+    void emitSourceFileInfo(const BasicSourceFileInfo &info) {
+      // Make 'FilePath' absolute for serialization;
+      SmallString<128> absolutePath = info.FilePath;
       llvm::sys::fs::make_absolute(absolutePath);
-      if (!seenFilenames.insert(absolutePath).second)
+
+      // Don't emit duplicated files.
+      if (!seenFilenames.insert(info.FilePath).second)
         return;
 
       auto fileID = FWriter.getTextOffset(absolutePath);
+      auto timestamp = std::chrono::duration_cast<std::chrono::seconds>(info.LastModified.time_since_epoch()).count();
+
       llvm::raw_svector_ostream out(Buffer);
       endian::Writer writer(out, little);
       writer.write<uint32_t>(fileID);
+      out << info.InterfaceHash.getRawValue();
+      writer.write<uint64_t>(timestamp);
+      writer.write<uint64_t>(info.FileSize);
     }
 
     SourceFileListWriter(StringWriter &FWriter) : FWriter(FWriter) {}
   } writer(FWriter);
 
   if (SourceFile *SF = MSF.dyn_cast<SourceFile *>()) {
-    writer.emitFilename(SF->getFilename());
+    BasicSourceFileInfo info;
+    SmallString<128> stash;
+    if (info.populate(SF))
+      return;
+    writer.emitSourceFileInfo(info);
   } else {
     auto *M = MSF.get<ModuleDecl *>();
-    M->collectSourceFileNames(
-        [&](StringRef filename) { writer.emitFilename(filename); });
+    M->collectBasicSourceFileInfo(
+        [&](const BasicSourceFileInfo &info) { writer.emitSourceFileInfo(info); });
   }
 
   const decl_locs_block::SourceFileListLayout FileList(Out);

lib/Serialization/SerializedModuleLoader.cpp

@@ -1328,7 +1328,7 @@ SerializedASTFile::getDiscriminatorForPrivateValue(const ValueDecl *D) const {
   return discriminator;
 }
 
-void SerializedASTFile::collectSourceFileNames(
-    llvm::function_ref<void(StringRef)> callback) const {
-  File.collectSourceFileNames(callback);
+void SerializedASTFile::collectBasicSourceFileInfo(
+    llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const {
+  File.collectBasicSourceFileInfo(callback);
 }