[Serialization] Make ModuleSearchPath a class with explicit getters

Improves debugging because you can set breakpoints on the getters and constructor.

Author: ahoppen

include/swift/AST/SearchPathOptions.h

@@ -36,7 +36,7 @@ enum class ModuleSearchPathKind {
 
 /// A single module search path that can come from different sources, e.g.
 /// framework search paths, import search path etc.
-struct ModuleSearchPath {
+class ModuleSearchPath {
   /// The actual path of the module search path. References a search path string
   /// stored inside \c SearchPathOptions, which must outlive this reference.
   StringRef Path;
@@ -52,6 +52,18 @@ struct ModuleSearchPath {
   /// different file names in \c searchPathsContainingFile.
   unsigned Index;
 
+public:
+  ModuleSearchPath(StringRef Path, ModuleSearchPathKind Kind, bool IsSystem,
+                   unsigned Index)
+      : Path(Path), Kind(Kind), IsSystem(IsSystem), Index(Index) {}
+
+  StringRef getPath() const { return Path; }
+  ModuleSearchPathKind getKind() const { return Kind; }
+
+  bool isSystem() const { return IsSystem; }
+
+  unsigned getIndex() const { return Index; }
+
   bool operator<(const ModuleSearchPath &Other) const {
     if (this->Kind == Other.Kind) {
       return this->Index < Other.Index;

lib/AST/SearchPathOptions.cpp

@@ -19,16 +19,22 @@ void ModuleSearchPathLookup::addFilesInPathToLookupTable(
     llvm::vfs::FileSystem *FS, StringRef SearchPath, ModuleSearchPathKind Kind,
     bool IsSystem, unsigned SearchPathIndex) {
   std::error_code Error;
-  assert(llvm::all_of(LookupTable, [&](const auto &LookupTableEntry) {
-    return llvm::none_of(LookupTableEntry.second, [&](const ModuleSearchPath &ExistingSearchPath) -> bool {
-      return ExistingSearchPath.Kind == Kind && ExistingSearchPath.Index == SearchPathIndex;
-    });
-  }) && "Search path with this kind and index already exists");
+  assert(llvm::all_of(
+             LookupTable,
+             [&](const auto &LookupTableEntry) {
+               return llvm::none_of(
+                   LookupTableEntry.second,
+                   [&](const ModuleSearchPath &ExistingSearchPath) -> bool {
+                     return ExistingSearchPath.getKind() == Kind &&
+                            ExistingSearchPath.getIndex() == SearchPathIndex;
+                   });
+             }) &&
+         "Search path with this kind and index already exists");
   for (auto Dir = FS->dir_begin(SearchPath, Error);
        !Error && Dir != llvm::vfs::directory_iterator(); Dir.increment(Error)) {
     StringRef Filename = llvm::sys::path::filename(Dir->path());
-    LookupTable[Filename].push_back(
-        {SearchPath, Kind, IsSystem, SearchPathIndex});
+    LookupTable[Filename].emplace_back(SearchPath, Kind, IsSystem,
+                                       SearchPathIndex);
   }
 }
 
@@ -92,7 +98,8 @@ ModuleSearchPathLookup::searchPathsContainingFile(
 
   for (auto &Filename : Filenames) {
     for (auto &Entry : LookupTable[Filename]) {
-      if (ResultIds.insert(std::make_pair(Entry.Kind, Entry.Index)).second) {
+      if (ResultIds.insert(std::make_pair(Entry.getKind(), Entry.getIndex()))
+              .second) {
         Result.push_back(&Entry);
       }
     }

lib/Serialization/SerializedModuleLoader.cpp

@@ -608,10 +608,10 @@ SerializedModuleLoaderBase::findModule(ImportPath::Element moduleID,
       InterestingFilenames, Ctx.SourceMgr.getFileSystem().get(),
       Ctx.LangOpts.Target.isOSDarwin());
   for (const auto &searchPath : searchPaths) {
-    currPath = searchPath->Path;
-    isSystemModule = searchPath->IsSystem;
+    currPath = searchPath->getPath();
+    isSystemModule = searchPath->isSystem();
 
-    switch (searchPath->Kind) {
+    switch (searchPath->getKind()) {
     case ModuleSearchPathKind::Import:
     case ModuleSearchPathKind::RuntimeLibrary: {
       isFramework = false;
@@ -621,7 +621,7 @@ SerializedModuleLoaderBase::findModule(ImportPath::Element moduleID,
       // This was not always true on non-Apple platforms, and in order to
       // ease the transition, check both layouts.
       bool checkTargetSpecificModule = true;
-      if (searchPath->Kind != ModuleSearchPathKind::RuntimeLibrary ||
+      if (searchPath->getKind() != ModuleSearchPathKind::RuntimeLibrary ||
           !Ctx.LangOpts.Target.isOSDarwin()) {
         auto modulePath = currPath;
         llvm::sys::path::append(modulePath, genericModuleFileName);