[Macros] Make 'PluginSearchOption' a external union

Create a 'Kind' enum so that deserialization can use the kind instead of
a string option name.

Author: rintaro

include/swift/AST/SearchPathOptions.h

@@ -14,8 +14,8 @@
 #define SWIFT_AST_SEARCHPATHOPTIONS_H
 
 #include "swift/Basic/ArrayRefView.h"
+#include "swift/Basic/ExternalUnion.h"
 #include "swift/Basic/PathRemapper.h"
-#include "swift/Basic/TaggedUnion.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringMap.h"
@@ -187,25 +187,81 @@ struct ExternalPluginSearchPathAndServerPath {
   std::string ServerPath;
 };
 
-namespace PluginSearchOption {
-struct LoadPluginLibrary {
-  std::string LibraryPath;
-};
-struct LoadPluginExecutable {
-  std::string ExecutablePath;
-  std::vector<std::string> ModuleNames;
-};
-struct PluginPath {
-  std::string SearchPath;
-};
-struct ExternalPluginPath {
-  std::string SearchPath;
-  std::string ServerPath;
-};
+class PluginSearchOption {
+public:
+  struct LoadPluginLibrary {
+    std::string LibraryPath;
+  };
+  struct LoadPluginExecutable {
+    std::string ExecutablePath;
+    std::vector<std::string> ModuleNames;
+  };
+  struct PluginPath {
+    std::string SearchPath;
+  };
+  struct ExternalPluginPath {
+    std::string SearchPath;
+    std::string ServerPath;
+  };
+
+  enum class Kind : uint8_t {
+    LoadPluginLibrary,
+    LoadPluginExecutable,
+    PluginPath,
+    ExternalPluginPath,
+  };
 
-using Value = TaggedUnion<LoadPluginLibrary, LoadPluginExecutable, PluginPath,
-                          ExternalPluginPath>;
-} // namespace PluginSearchOption
+private:
+  using Members = ExternalUnionMembers<LoadPluginLibrary, LoadPluginExecutable,
+                                       PluginPath, ExternalPluginPath>;
+  static Members::Index getIndexForKind(Kind kind) {
+    switch (kind) {
+    case Kind::LoadPluginLibrary:
+      return Members::indexOf<LoadPluginLibrary>();
+    case Kind::LoadPluginExecutable:
+      return Members::indexOf<LoadPluginExecutable>();
+    case Kind::PluginPath:
+      return Members::indexOf<PluginPath>();
+    case Kind::ExternalPluginPath:
+      return Members::indexOf<ExternalPluginPath>();
+    }
+  };
+  using Storage = ExternalUnion<Kind, Members, getIndexForKind>;
+
+  Kind kind;
+  Storage storage;
+
+public:
+  PluginSearchOption(const LoadPluginLibrary &v)
+      : kind(Kind::LoadPluginLibrary) {
+    storage.emplace<LoadPluginLibrary>(kind, v);
+  }
+  PluginSearchOption(const LoadPluginExecutable &v)
+      : kind(Kind::LoadPluginExecutable) {
+    storage.emplace<LoadPluginExecutable>(kind, v);
+  }
+  PluginSearchOption(const PluginPath &v) : kind(Kind::PluginPath) {
+    storage.emplace<PluginPath>(kind, v);
+  }
+  PluginSearchOption(const ExternalPluginPath &v)
+      : kind(Kind::ExternalPluginPath) {
+    storage.emplace<ExternalPluginPath>(kind, v);
+  }
+
+  Kind getKind() const { return kind; }
+
+  template <typename T>
+  const T *dyn_cast() const {
+    if (Members::indexOf<T>() != getIndexForKind(kind))
+      return nullptr;
+    return &storage.get<T>(kind);
+  }
+
+  template <typename T>
+  const T &get() const {
+    return storage.get<T>(kind);
+  }
+};
 
 /// Options for controlling search path behavior.
 class SearchPathOptions {
@@ -383,7 +439,7 @@ class SearchPathOptions {
   std::vector<std::string> RuntimeLibraryPaths;
 
   /// Plugin search path options.
-  std::vector<PluginSearchOption::Value> PluginSearchOpts;
+  std::vector<PluginSearchOption> PluginSearchOpts;
 
   /// Don't look in for compiler-provided modules.
   bool SkipRuntimeLibraryImportPaths = false;

include/swift/Serialization/SerializationOptions.h

@@ -44,7 +44,7 @@ namespace swift {
     StringRef ModuleLinkName;
     StringRef ModuleInterface;
     std::vector<std::string> ExtraClangOptions;
-    std::vector<swift::PluginSearchOption::Value> PluginSearchOptions;
+    std::vector<swift::PluginSearchOption> PluginSearchOptions;
 
     /// Path prefixes that should be rewritten in debug info.
     PathRemapper DebuggingOptionsPrefixMap;

include/swift/Serialization/Validation.h

@@ -111,7 +111,8 @@ struct ValidationInfo {
 class ExtendedValidationInfo {
   SmallVector<StringRef, 4> ExtraClangImporterOpts;
 
-  SmallVector<std::pair<StringRef, StringRef>, 2> PluginSearchOptions;
+  SmallVector<std::pair<PluginSearchOption::Kind, StringRef>, 2>
+      PluginSearchOptions;
 
   std::string SDKPath;
   StringRef ModuleABIName;
@@ -146,10 +147,12 @@ class ExtendedValidationInfo {
     ExtraClangImporterOpts.push_back(option);
   }
 
-  ArrayRef<std::pair<StringRef, StringRef>> getPluginSearchOptions() const {
+  ArrayRef<std::pair<PluginSearchOption::Kind, StringRef>>
+  getPluginSearchOptions() const {
     return PluginSearchOptions;
   }
-  void addPluginSearchOption(const std::pair<StringRef, StringRef> &opt) {
+  void addPluginSearchOption(
+      const std::pair<PluginSearchOption::Kind, StringRef> &opt) {
     PluginSearchOptions.push_back(opt);
   }
 

lib/AST/PluginLoader.cpp

@@ -61,27 +61,31 @@ PluginLoader::lookupPluginByModuleName(Identifier moduleName) {
 
   // FIXME: Should we create a lookup table keyed by module name?
   for (auto &entry : Ctx.SearchPathOpts.PluginSearchOpts) {
-    using namespace PluginSearchOption;
+    switch (entry.getKind()) {
     // Try '-load-plugin-library'.
-    if (auto *val = entry.dyn_cast<LoadPluginLibrary>()) {
-      if (llvm::sys::path::filename(val->LibraryPath) == pluginLibBasename) {
-        return {val->LibraryPath, ""};
+    case PluginSearchOption::Kind::LoadPluginLibrary: {
+      auto &val = entry.get<PluginSearchOption::LoadPluginLibrary>();
+      if (llvm::sys::path::filename(val.LibraryPath) == pluginLibBasename) {
+        return {val.LibraryPath, ""};
       }
       continue;
     }
 
     // Try '-load-plugin-executable'.
-    if (auto *v = entry.dyn_cast<LoadPluginExecutable>()) {
+    case PluginSearchOption::Kind::LoadPluginExecutable: {
+      auto &val = entry.get<PluginSearchOption::LoadPluginExecutable>();
       auto found = ExecutablePluginPaths.find(moduleName);
-      if (found != ExecutablePluginPaths.end()) {
-        return {"", std::string(found->second)};
+      if (found != ExecutablePluginPaths.end() &&
+          found->second == val.ExecutablePath) {
+        return {"", val.ExecutablePath};
       }
       continue;
     }
 
     // Try '-plugin-path'.
-    if (auto *v = entry.dyn_cast<PluginPath>()) {
-      SmallString<128> fullPath(v->SearchPath);
+    case PluginSearchOption::Kind::PluginPath: {
+      auto &val = entry.get<PluginSearchOption::PluginPath>();
+      SmallString<128> fullPath(val.SearchPath);
       llvm::sys::path::append(fullPath, pluginLibBasename);
       if (fs->exists(fullPath)) {
         return {std::string(fullPath), ""};
@@ -90,14 +94,16 @@ PluginLoader::lookupPluginByModuleName(Identifier moduleName) {
     }
 
     // Try '-external-plugin-path'.
-    if (auto *v = entry.dyn_cast<ExternalPluginPath>()) {
-      SmallString<128> fullPath(v->SearchPath);
+    case PluginSearchOption::Kind::ExternalPluginPath: {
+      auto &val = entry.get<PluginSearchOption::ExternalPluginPath>();
+      SmallString<128> fullPath(val.SearchPath);
       llvm::sys::path::append(fullPath, pluginLibBasename);
       if (fs->exists(fullPath)) {
-        return {std::string(fullPath), v->ServerPath};
+        return {std::string(fullPath), val.ServerPath};
       }
       continue;
     }
+    }
   }
 
   return {};

lib/Serialization/ModuleFileSharedCore.cpp

@@ -127,24 +127,24 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
       extendedInfo.addExtraClangImporterOption(blobData);
       break;
     case options_block::PLUGIN_SEARCH_OPTION: {
-      unsigned optKind;
+      PluginSearchOption::Kind optKind;
       StringRef optStr;
       options_block::ResilienceStrategyLayout::readRecord(scratch, optKind);
       switch (PluginSearchOptionKind(optKind)) {
       case PluginSearchOptionKind::PluginPath:
-        optStr = "-plugin-path";
+        optKind = PluginSearchOption::Kind::PluginPath;
         break;
       case PluginSearchOptionKind::ExternalPluginPath:
-        optStr = "-external-plugin-path";
+        optKind = PluginSearchOption::Kind::ExternalPluginPath;
         break;
       case PluginSearchOptionKind::LoadPluginLibrary:
-        optStr = "-load-plugin-library";
+        optKind = PluginSearchOption::Kind::LoadPluginLibrary;
         break;
       case PluginSearchOptionKind::LoadPluginExecutable:
-        optStr = "-load-plugin-executable";
+        optKind = PluginSearchOption::Kind::LoadPluginExecutable;
         break;
       }
-      extendedInfo.addPluginSearchOption({optStr, blobData});
+      extendedInfo.addPluginSearchOption({optKind, blobData});
       break;
     }
     case options_block::IS_SIB:

lib/Serialization/Serialization.cpp

@@ -1137,39 +1137,42 @@ void Serializer::writeHeader(const SerializationOptions &options) {
         // Macro plugins
         options_block::PluginSearchOptionLayout PluginSearchOpt(Out);
         for (auto &elem : options.PluginSearchOptions) {
-          if (auto *opt = elem.dyn_cast<PluginSearchOption::PluginPath>()) {
+          switch (elem.getKind()) {
+          case PluginSearchOption::Kind::PluginPath: {
+            auto &opt = elem.get<PluginSearchOption::PluginPath>();
             PluginSearchOpt.emit(ScratchRecord,
                                  uint8_t(PluginSearchOptionKind::PluginPath),
-                                 opt->SearchPath);
+                                 opt.SearchPath);
             continue;
           }
-          if (auto *opt =
-                  elem.dyn_cast<PluginSearchOption::ExternalPluginPath>()) {
+          case PluginSearchOption::Kind::ExternalPluginPath: {
+            auto &opt = elem.get<PluginSearchOption::ExternalPluginPath>();
             PluginSearchOpt.emit(
                 ScratchRecord,
                 uint8_t(PluginSearchOptionKind::ExternalPluginPath),
-                opt->SearchPath + "#" + opt->ServerPath);
+                opt.SearchPath + "#" + opt.ServerPath);
             continue;
           }
-          if (auto *opt =
-                  elem.dyn_cast<PluginSearchOption::LoadPluginLibrary>()) {
+          case PluginSearchOption::Kind::LoadPluginLibrary: {
+            auto &opt = elem.get<PluginSearchOption::LoadPluginLibrary>();
             PluginSearchOpt.emit(
                 ScratchRecord,
                 uint8_t(PluginSearchOptionKind::LoadPluginLibrary),
-                opt->LibraryPath);
+                opt.LibraryPath);
             continue;
           }
-          if (auto *opt =
-                  elem.dyn_cast<PluginSearchOption::LoadPluginExecutable>()) {
-            std::string optStr = opt->ExecutablePath + "#";
+          case PluginSearchOption::Kind::LoadPluginExecutable: {
+            auto &opt = elem.get<PluginSearchOption::LoadPluginExecutable>();
+            std::string optStr = opt.ExecutablePath + "#";
             llvm::interleave(
-                opt->ModuleNames, [&](auto &name) { optStr += name; },
+                opt.ModuleNames, [&](auto &name) { optStr += name; },
                 [&]() { optStr += ","; });
             PluginSearchOpt.emit(
                 ScratchRecord,
                 uint8_t(PluginSearchOptionKind::LoadPluginExecutable), optStr);
             continue;
           }
+          }
         }
       }
     }

tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp

@@ -91,7 +91,22 @@ static bool validateModule(
     }
     llvm::outs() << "- Plugin Search Options:\n";
     for (auto opt : extendedInfo.getPluginSearchOptions()) {
-      llvm::outs() << "    " << opt.first << " " << opt.second << "\n";
+      StringRef optStr;
+      switch (opt.first) {
+      case swift::PluginSearchOption::Kind::PluginPath:
+        optStr = "-plugin-path";
+        break;
+      case swift::PluginSearchOption::Kind::ExternalPluginPath:
+        optStr = "-external-plugin-path";
+        break;
+      case swift::PluginSearchOption::Kind::LoadPluginLibrary:
+        optStr = "-load-plugin-library";
+        break;
+      case swift::PluginSearchOption::Kind::LoadPluginExecutable:
+        optStr = "-load-plugin-executable";
+        break;
+      }
+      llvm::outs() << "    " << optStr << " " << opt.second << "\n";
     }
   }