Replace PlatformKind with PlatformType.

[ributzka]

Summary

The PlatformKind/PlatformType enums contain the same information, which requires
them to be kept in-sync. This commit changes over to PlatformType as the sole
source of truth, which allows the removal of the redundant PlatformKind.

The majority of the changes were in LLD and TextAPI.

[int3]

Nice! The two enums always seemed kind of redundant to me, so thanks for cleaning it up :)

The LLD changes lgtm, I'll let someone else look at the TextAPI ones

[ributzka]

The unit test failure on Windows seems unrelated, because I have seen it in a previous pre-merge check too. Furthermore, this should be a NFC.

lld/MachO/Config.h

struct Configuration {
   SymbolPatterns unexportedSymbols;
 
   bool zeroModTime = false;
 
   llvm::StringRef osoPrefix;
 
   llvm::MachO::Architecture arch() const { return platformInfo.target.Arch; }
 
-  llvm::MachO::PlatformKind platform() const {
+  llvm::MachO::PlatformType platform() const {
     return platformInfo.target.Platform;
   }
 };
 
 // The symbol with the highest priority should be ordered first in the output
 // section (modulo input section contiguity constraints). Using priority
 // (highest first) instead of order (lowest first) has the convenient property
 // that the default-constructed zero priority -- for symbols/sections without a

lld/MachO/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_DRIVER_H
 #define LLD_MACHO_DRIVER_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <set>
 #include <type_traits>
 
-namespace llvm {
-namespace MachO {
-class InterfaceFile;
-enum class PlatformKind : unsigned;
-} // namespace MachO
-} // namespace llvm
-
 namespace lld {
 namespace macho {
 
 class DylibFile;
 class InputFile;
 
 class MachOOptTable : public llvm::opt::OptTable {
 public:

 // rerooted.
 llvm::StringRef rerootPath(llvm::StringRef path);
 
 uint32_t getModTime(llvm::StringRef path);
 
 void printArchiveMemberLoad(StringRef reason, const InputFile *);
 
 // Map simulator platforms to their underlying device platform.
-llvm::MachO::PlatformKind removeSimulator(llvm::MachO::PlatformKind platform);
+llvm::MachO::PlatformType removeSimulator(llvm::MachO::PlatformType platform);
 
 // Helper class to export dependency info.
 class DependencyTracker {
 public:
   explicit DependencyTracker(llvm::StringRef path);
 
   // Adds the given path to the set of not-found files.
   inline void logFileNotFound(const Twine &path) {

lld/MachO/Driver.cpp

 }
 
 static std::string lowerDash(StringRef s) {
   return std::string(map_iterator(s.begin(), toLowerDash),
                      map_iterator(s.end(), toLowerDash));
 }
 
 // Has the side-effect of setting Config::platformInfo.
-static PlatformKind parsePlatformVersion(const ArgList &args) {
+static PlatformType parsePlatformVersion(const ArgList &args) {
   const Arg *arg = args.getLastArg(OPT_platform_version);
   if (!arg) {
     error("must specify -platform_version");
-    return PlatformKind::unknown;
+    return PLATFORM_UNKNOWN;
   }
 
   StringRef platformStr = arg->getValue(0);
   StringRef minVersionStr = arg->getValue(1);
   StringRef sdkVersionStr = arg->getValue(2);
 
   // TODO(compnerd) see if we can generate this case list via XMACROS
-  PlatformKind platform =
-      StringSwitch<PlatformKind>(lowerDash(platformStr))
-          .Cases("macos", "1", PlatformKind::macOS)
-          .Cases("ios", "2", PlatformKind::iOS)
-          .Cases("tvos", "3", PlatformKind::tvOS)
-          .Cases("watchos", "4", PlatformKind::watchOS)
-          .Cases("bridgeos", "5", PlatformKind::bridgeOS)
-          .Cases("mac-catalyst", "6", PlatformKind::macCatalyst)
-          .Cases("ios-simulator", "7", PlatformKind::iOSSimulator)
-          .Cases("tvos-simulator", "8", PlatformKind::tvOSSimulator)
-          .Cases("watchos-simulator", "9", PlatformKind::watchOSSimulator)
-          .Cases("driverkit", "10", PlatformKind::driverKit)
-          .Default(PlatformKind::unknown);
-  if (platform == PlatformKind::unknown)
+  PlatformType platform =
+      StringSwitch<PlatformType>(lowerDash(platformStr))
+          .Cases("macos", "1", PLATFORM_MACOS)
+          .Cases("ios", "2", PLATFORM_IOS)
+          .Cases("tvos", "3", PLATFORM_TVOS)
+          .Cases("watchos", "4", PLATFORM_WATCHOS)
+          .Cases("bridgeos", "5", PLATFORM_BRIDGEOS)
+          .Cases("mac-catalyst", "6", PLATFORM_MACCATALYST)
+          .Cases("ios-simulator", "7", PLATFORM_IOSSIMULATOR)
+          .Cases("tvos-simulator", "8", PLATFORM_TVOSSIMULATOR)
+          .Cases("watchos-simulator", "9", PLATFORM_WATCHOSSIMULATOR)
+          .Cases("driverkit", "10", PLATFORM_DRIVERKIT)
+          .Default(PLATFORM_UNKNOWN);
+  if (platform == PLATFORM_UNKNOWN)
     error(Twine("malformed platform: ") + platformStr);
   // TODO: check validity of version strings, which varies by platform
   // NOTE: ld64 accepts version strings with 5 components
   // llvm::VersionTuple accepts no more than 4 components
   // Has Apple ever published version strings with 5 components?
   if (config->platformInfo.minimum.tryParse(minVersionStr))
     error(Twine("malformed minimum version: ") + minVersionStr);
   if (config->platformInfo.sdk.tryParse(sdkVersionStr))
     error(Twine("malformed sdk version: ") + sdkVersionStr);
   return platform;
 }
 
 // Has the side-effect of setting Config::target.
 static TargetInfo *createTargetInfo(InputArgList &args) {
   StringRef archName = args.getLastArgValue(OPT_arch);
   if (archName.empty()) {
     error("must specify -arch");
     return nullptr;
   }
 
-  PlatformKind platform = parsePlatformVersion(args);
+  PlatformType platform = parsePlatformVersion(args);
   config->platformInfo.target =
       MachO::Target(getArchitectureFromName(archName), platform);
 
   uint32_t cpuType;
   uint32_t cpuSubtype;
   std::tie(cpuType, cpuSubtype) = getCPUTypeFromArchitecture(config->arch());
 
   switch (cpuType) {
if (!isPowerOf2_32(align)) {
             "' (in base 16) not a power of two");
       continue;
     }
     sectAligns.push_back({segName, sectName, align});
   }
   return sectAligns;
 }
 
-PlatformKind macho::removeSimulator(PlatformKind platform) {
+PlatformType macho::removeSimulator(PlatformType platform) {
   switch (platform) {
-  case PlatformKind::iOSSimulator:
-    return PlatformKind::iOS;
-  case PlatformKind::tvOSSimulator:
-    return PlatformKind::tvOS;
-  case PlatformKind::watchOSSimulator:
-    return PlatformKind::watchOS;
+  case PLATFORM_IOSSIMULATOR:
+    return PLATFORM_IOS;
+  case PLATFORM_TVOSSIMULATOR:
+    return PLATFORM_TVOS;
+  case PLATFORM_WATCHOSSIMULATOR:
+    return PLATFORM_WATCHOS;
   default:
     return platform;
   }
 }
 
 static bool dataConstDefault(const InputArgList &args) {
-  static const std::vector<std::pair<PlatformKind, VersionTuple>> minVersion = {
-      {PlatformKind::macOS, VersionTuple(10, 15)},
-      {PlatformKind::iOS, VersionTuple(13, 0)},
-      {PlatformKind::tvOS, VersionTuple(13, 0)},
-      {PlatformKind::watchOS, VersionTuple(6, 0)},
-      {PlatformKind::bridgeOS, VersionTuple(4, 0)}};
-  PlatformKind platform = removeSimulator(config->platformInfo.target.Platform);
+  static const std::vector<std::pair<PlatformType, VersionTuple>> minVersion = {
+      {PLATFORM_MACOS, VersionTuple(10, 15)},
+      {PLATFORM_IOS, VersionTuple(13, 0)},
+      {PLATFORM_TVOS, VersionTuple(13, 0)},
+      {PLATFORM_WATCHOS, VersionTuple(6, 0)},
+      {PLATFORM_BRIDGEOS, VersionTuple(4, 0)}};
+  PlatformType platform = removeSimulator(config->platformInfo.target.Platform);
   auto it = llvm::find_if(minVersion,
                           [&](const auto &p) { return p.first == platform; });
   if (it != minVersion.end())
     if (config->platformInfo.minimum < it->second)
       return false;
 
   switch (config->outputType) {
   case MH_EXECUTE:
config->warnDylibInstallName = args.hasFlag(
       OPT_warn_dylib_install_name, OPT_no_warn_dylib_install_name, false);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   config->printSymbolOrder = args.getLastArgValue(OPT_print_symbol_order);
 
   // FIXME: Add a commandline flag for this too.
   config->zeroModTime = getenv("ZERO_AR_DATE");
 
-  std::array<PlatformKind, 3> encryptablePlatforms{
-      PlatformKind::iOS, PlatformKind::watchOS, PlatformKind::tvOS};
+  std::array<PlatformType, 3> encryptablePlatforms{
+      PLATFORM_IOS, PLATFORM_WATCHOS, PLATFORM_TVOS};
   config->emitEncryptionInfo =
       args.hasFlag(OPT_encryptable, OPT_no_encryption,
                    is_contained(encryptablePlatforms, config->platform()));
 
 #ifndef LLVM_HAVE_LIBXAR
   if (config->emitBitcodeBundle)
     error("-bitcode_bundle unsupported because LLD wasn't built with libxar");
 #endif
for (const CachedHashStringRef &cachedName : config->exportedSymbols.literals)
     symtab->addUndefined(cachedName.val(), /*file=*/nullptr,
                          /*isWeakRef=*/false);
 
   config->saveTemps = args.hasArg(OPT_save_temps);
 
   config->adhocCodesign = args.hasFlag(
       OPT_adhoc_codesign, OPT_no_adhoc_codesign,
       (config->arch() == AK_arm64 || config->arch() == AK_arm64e) &&
-          config->platform() == PlatformKind::macOS);
+          config->platform() == PLATFORM_MACOS);
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion(), lld::errs());
     message(StringRef("Library search paths:") +
                 (config->librarySearchPaths.empty()
                      ? ""
                      : "\n\t" + join(config->librarySearchPaths, "\n\t")),
             lld::errs());

lld/MachO/InputFiles.cpp

static std::vector<PlatformInfo> getPlatformInfos(const InputFile *input) {
   if (!isa<ObjFile>(input) && !isa<DylibFile>(input))
     return {};
 
   const char *hdr = input->mb.getBufferStart();
 
   std::vector<PlatformInfo> platformInfos;
   for (auto *cmd : findCommands<build_version_command>(hdr, LC_BUILD_VERSION)) {
     PlatformInfo info;
-    info.target.Platform = static_cast<PlatformKind>(cmd->platform);
+    info.target.Platform = static_cast<PlatformType>(cmd->platform);
     info.minimum = decodeVersion(cmd->minos);
     platformInfos.emplace_back(std::move(info));
   }
   for (auto *cmd : findCommands<version_min_command>(
            hdr, LC_VERSION_MIN_MACOSX, LC_VERSION_MIN_IPHONEOS,
            LC_VERSION_MIN_TVOS, LC_VERSION_MIN_WATCHOS)) {
     PlatformInfo info;
     switch (cmd->cmd) {
     case LC_VERSION_MIN_MACOSX:
-      info.target.Platform = PlatformKind::macOS;
+      info.target.Platform = PLATFORM_MACOS;
       break;
     case LC_VERSION_MIN_IPHONEOS:
-      info.target.Platform = PlatformKind::iOS;
+      info.target.Platform = PLATFORM_IOS;
       break;
     case LC_VERSION_MIN_TVOS:
-      info.target.Platform = PlatformKind::tvOS;
+      info.target.Platform = PLATFORM_TVOS;
       break;
     case LC_VERSION_MIN_WATCHOS:
-      info.target.Platform = PlatformKind::watchOS;
+      info.target.Platform = PLATFORM_WATCHOS;
       break;
     }
     info.minimum = decodeVersion(cmd->version);
     platformInfos.emplace_back(std::move(info));
   }
 
   return platformInfos;
 }

lld/MachO/SyntheticSections.cpp

uint64_t MachHeaderSection::getSize() const {
   return size;
 }
 
 static uint32_t cpuSubtype() {
   uint32_t subtype = target->cpuSubtype;
 
   if (config->outputType == MH_EXECUTE && !config->staticLink &&
       target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
-      config->platform() == PlatformKind::macOS &&
+      config->platform() == PLATFORM_MACOS &&
       config->platformInfo.minimum >= VersionTuple(10, 5))
     subtype |= CPU_SUBTYPE_LIB64;
 
   return subtype;
 }
 
 void MachHeaderSection::writeTo(uint8_t *buf) const {
   auto *hdr = reinterpret_cast<mach_header *>(buf);

lld/MachO/Writer.cpp

public:
   explicit LCMinVersion(const PlatformInfo &platformInfo)
       : platformInfo(platformInfo) {}
 
   uint32_t getSize() const override { return sizeof(version_min_command); }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<version_min_command *>(buf);
     switch (platformInfo.target.Platform) {
-    case PlatformKind::macOS:
+    case PLATFORM_MACOS:
       c->cmd = LC_VERSION_MIN_MACOSX;
       break;
-    case PlatformKind::iOS:
-    case PlatformKind::iOSSimulator:
+    case PLATFORM_IOS:
+    case PLATFORM_IOSSIMULATOR:
       c->cmd = LC_VERSION_MIN_IPHONEOS;
       break;
-    case PlatformKind::tvOS:
-    case PlatformKind::tvOSSimulator:
+    case PLATFORM_TVOS:
+    case PLATFORM_TVOSSIMULATOR:
       c->cmd = LC_VERSION_MIN_TVOS;
       break;
-    case PlatformKind::watchOS:
-    case PlatformKind::watchOSSimulator:
+    case PLATFORM_WATCHOS:
+    case PLATFORM_WATCHOSSIMULATOR:
       c->cmd = LC_VERSION_MIN_WATCHOS;
       break;
     default:
       llvm_unreachable("invalid platform");
       break;
     }
     c->cmdsize = getSize();
     c->version = encodeVersion(platformInfo.minimum);
if (auto *objFile = dyn_cast<ObjFile>(file))
             in.unwindInfo->addSymbol(defined);
         }
       }
   }
 }
 
 // TODO: ld64 enforces the old load commands in a few other cases.
 static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
-  static const std::vector<std::pair<PlatformKind, VersionTuple>> minVersion = {
-      {PlatformKind::macOS, VersionTuple(10, 14)},
-      {PlatformKind::iOS, VersionTuple(12, 0)},
-      {PlatformKind::iOSSimulator, VersionTuple(13, 0)},
-      {PlatformKind::tvOS, VersionTuple(12, 0)},
-      {PlatformKind::tvOSSimulator, VersionTuple(13, 0)},
-      {PlatformKind::watchOS, VersionTuple(5, 0)},
-      {PlatformKind::watchOSSimulator, VersionTuple(6, 0)}};
+  static const std::vector<std::pair<PlatformType, VersionTuple>> minVersion = {
+      {PLATFORM_MACOS, VersionTuple(10, 14)},
+      {PLATFORM_IOS, VersionTuple(12, 0)},
+      {PLATFORM_IOSSIMULATOR, VersionTuple(13, 0)},
+      {PLATFORM_TVOS, VersionTuple(12, 0)},
+      {PLATFORM_TVOSSIMULATOR, VersionTuple(13, 0)},
+      {PLATFORM_WATCHOS, VersionTuple(5, 0)},
+      {PLATFORM_WATCHOSSIMULATOR, VersionTuple(6, 0)}};
   auto it = llvm::find_if(minVersion, [&](const auto &p) {
     return p.first == platformInfo.target.Platform;
   });
   return it == minVersion.end() ? true : platformInfo.minimum >= it->second;
 }
 
 template <class LP> void Writer::createLoadCommands() {
   uint8_t segIndex = 0;

llvm/include/llvm/BinaryFormat/MachO.h

 };
 
 // Values for segment_command.initprot.
 // From <mach/vm_prot.h>
 enum { VM_PROT_READ = 0x1, VM_PROT_WRITE = 0x2, VM_PROT_EXECUTE = 0x4 };
 
 // Values for platform field in build_version_command.
 enum PlatformType {
+  PLATFORM_UNKNOWN = 0,
   PLATFORM_MACOS = 1,
   PLATFORM_IOS = 2,
   PLATFORM_TVOS = 3,
   PLATFORM_WATCHOS = 4,
   PLATFORM_BRIDGEOS = 5,
   PLATFORM_MACCATALYST = 6,
   PLATFORM_IOSSIMULATOR = 7,
   PLATFORM_TVOSSIMULATOR = 8,

llvm/include/llvm/TextAPI/Platform.h

 #define LLVM_TEXTAPI_PLATFORM_H
 
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 namespace llvm {
 namespace MachO {
 
-/// Defines the list of MachO platforms.
-enum class PlatformKind : unsigned {
-  unknown,
-  macOS = MachO::PLATFORM_MACOS,
-  iOS = MachO::PLATFORM_IOS,
-  tvOS = MachO::PLATFORM_TVOS,
-  watchOS = MachO::PLATFORM_WATCHOS,
-  bridgeOS = MachO::PLATFORM_BRIDGEOS,
-  macCatalyst = MachO::PLATFORM_MACCATALYST,
-  iOSSimulator = MachO::PLATFORM_IOSSIMULATOR,
-  tvOSSimulator = MachO::PLATFORM_TVOSSIMULATOR,
-  watchOSSimulator = MachO::PLATFORM_WATCHOSSIMULATOR,
-  driverKit = MachO::PLATFORM_DRIVERKIT,
-};
+using PlatformSet = SmallSet<PlatformType, 3>;
 
-using PlatformSet = SmallSet<PlatformKind, 3>;
-
-PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim);
-PlatformKind mapToPlatformKind(const Triple &Target);
+PlatformType mapToPlatformType(PlatformType Platform, bool WantSim);
+PlatformType mapToPlatformType(const Triple &Target);
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets);
-StringRef getPlatformName(PlatformKind Platform);
-PlatformKind getPlatformFromName(StringRef Name);
-std::string getOSAndEnvironmentName(PlatformKind Platform,
+StringRef getPlatformName(PlatformType Platform);
+PlatformType getPlatformFromName(StringRef Name);
+std::string getOSAndEnvironmentName(PlatformType Platform,
                                     std::string Version = "");
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_PLATFORM_H

llvm/include/llvm/TextAPI/Target.h

 namespace MachO {
 
 // This is similar to a llvm Triple, but the triple doesn't have all the
 // information we need. For example there is no enum value for x86_64h. The
 // only way to get that information is to parse the triple string.
 class Target {
 public:
   Target() = default;
-  Target(Architecture Arch, PlatformKind Platform)
+  Target(Architecture Arch, PlatformType Platform)
       : Arch(Arch), Platform(Platform) {}
   explicit Target(const llvm::Triple &Triple)
-      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformKind(Triple)) {}
+      : Arch(mapToArchitecture(Triple)), Platform(mapToPlatformType(Triple)) {}
 
   static llvm::Expected<Target> create(StringRef Target);
 
   operator std::string() const;
 
   Architecture Arch;
-  PlatformKind Platform;
+  PlatformType Platform;
 };
 
 inline bool operator==(const Target &LHS, const Target &RHS) {
   return std::tie(LHS.Arch, LHS.Platform) == std::tie(RHS.Arch, RHS.Platform);
 }
 
 inline bool operator!=(const Target &LHS, const Target &RHS) {
   return std::tie(LHS.Arch, LHS.Platform) != std::tie(RHS.Arch, RHS.Platform);

llvm/lib/MC/MCAsmStreamer.cpp

void MCAsmStreamer::emitVersionMin(MCVersionMinType Type, unsigned Major,
   if (Update)
     OS << ", " << Update;
   EmitSDKVersionSuffix(OS, SDKVersion);
   EmitEOL();
 }
 
 static const char *getPlatformName(MachO::PlatformType Type) {
   switch (Type) {
+  case MachO::PLATFORM_UNKNOWN: /* silence warning*/
+    break;
   case MachO::PLATFORM_MACOS:            return "macos";
   case MachO::PLATFORM_IOS:              return "ios";
   case MachO::PLATFORM_TVOS:             return "tvos";
   case MachO::PLATFORM_WATCHOS:          return "watchos";
   case MachO::PLATFORM_BRIDGEOS:         return "bridgeos";
   case MachO::PLATFORM_MACCATALYST:      return "macCatalyst";
   case MachO::PLATFORM_IOSSIMULATOR:     return "iossimulator";
   case MachO::PLATFORM_TVOSSIMULATOR:    return "tvossimulator";

llvm/lib/MC/MCParser/DarwinAsmParser.cpp

bool DarwinAsmParser::parseVersionMin(StringRef Directive, SMLoc Loc,
   Triple::OSType ExpectedOS = getOSTypeFromMCVM(Type);
   checkVersion(Directive, StringRef(), Loc, ExpectedOS);
   getStreamer().emitVersionMin(Type, Major, Minor, Update, SDKVersion);
   return false;
 }
 
 static Triple::OSType getOSTypeFromPlatform(MachO::PlatformType Type) {
   switch (Type) {
+  case MachO::PLATFORM_UNKNOWN: /* silence warning */
+    break;
   case MachO::PLATFORM_MACOS:   return Triple::MacOSX;
   case MachO::PLATFORM_IOS:     return Triple::IOS;
   case MachO::PLATFORM_TVOS:    return Triple::TvOS;
   case MachO::PLATFORM_WATCHOS: return Triple::WatchOS;
   case MachO::PLATFORM_BRIDGEOS:         /* silence warning */ break;
   case MachO::PLATFORM_MACCATALYST: return Triple::IOS;
   case MachO::PLATFORM_IOSSIMULATOR:     /* silence warning */ break;
   case MachO::PLATFORM_TVOSSIMULATOR:    /* silence warning */ break;

llvm/lib/Object/TapiFile.cpp

for (const auto *Symbol : interface.symbols()) {
     if (!Symbol->getArchitectures().has(Arch))
       continue;
 
     switch (Symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       Symbols.emplace_back(StringRef(), Symbol->getName(), getFlags(Symbol));
       break;
     case SymbolKind::ObjectiveCClass:
-      if (interface.getPlatforms().count(PlatformKind::macOS) &&
-          Arch == AK_i386) {
+      if (interface.getPlatforms().count(PLATFORM_MACOS) && Arch == AK_i386) {
         Symbols.emplace_back(ObjC1ClassNamePrefix, Symbol->getName(),
                              getFlags(Symbol));
       } else {
         Symbols.emplace_back(ObjC2ClassNamePrefix, Symbol->getName(),
                              getFlags(Symbol));
         Symbols.emplace_back(ObjC2MetaClassNamePrefix, Symbol->getName(),
                              getFlags(Symbol));
       }

llvm/lib/TextAPI/Platform.cpp

 #include "llvm/TextAPI/Platform.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 
 namespace llvm {
 namespace MachO {
 
-PlatformKind mapToPlatformKind(PlatformKind Platform, bool WantSim) {
+PlatformType mapToPlatformType(PlatformType Platform, bool WantSim) {
   switch (Platform) {
   default:
     return Platform;
-  case PlatformKind::iOS:
-    return WantSim ? PlatformKind::iOSSimulator : PlatformKind::iOS;
-  case PlatformKind::tvOS:
-    return WantSim ? PlatformKind::tvOSSimulator : PlatformKind::tvOS;
-  case PlatformKind::watchOS:
-    return WantSim ? PlatformKind::watchOSSimulator : PlatformKind::watchOS;
+  case PLATFORM_IOS:
+    return WantSim ? PLATFORM_IOSSIMULATOR : PLATFORM_IOS;
+  case PLATFORM_TVOS:
+    return WantSim ? PLATFORM_TVOSSIMULATOR : PLATFORM_TVOS;
+  case PLATFORM_WATCHOS:
+    return WantSim ? PLATFORM_WATCHOSSIMULATOR : PLATFORM_WATCHOS;
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
-PlatformKind mapToPlatformKind(const Triple &Target) {
+PlatformType mapToPlatformType(const Triple &Target) {
   switch (Target.getOS()) {
   default:
-    return PlatformKind::unknown;
+    return PLATFORM_UNKNOWN;
   case Triple::MacOSX:
-    return PlatformKind::macOS;
+    return PLATFORM_MACOS;
   case Triple::IOS:
     if (Target.isSimulatorEnvironment())
-      return PlatformKind::iOSSimulator;
+      return PLATFORM_IOSSIMULATOR;
     if (Target.getEnvironment() == Triple::MacABI)
-      return PlatformKind::macCatalyst;
-    return PlatformKind::iOS;
+      return PLATFORM_MACCATALYST;
+    return PLATFORM_IOS;
   case Triple::TvOS:
-    return Target.isSimulatorEnvironment() ? PlatformKind::tvOSSimulator
-                                           : PlatformKind::tvOS;
+    return Target.isSimulatorEnvironment() ? PLATFORM_TVOSSIMULATOR
+                                           : PLATFORM_TVOS;
   case Triple::WatchOS:
-    return Target.isSimulatorEnvironment() ? PlatformKind::watchOSSimulator
-                                           : PlatformKind::watchOS;
+    return Target.isSimulatorEnvironment() ? PLATFORM_WATCHOSSIMULATOR
+                                           : PLATFORM_WATCHOS;
     // TODO: add bridgeOS & driverKit once in llvm::Triple
   }
-  llvm_unreachable("Unknown Target Triple");
 }
 
 PlatformSet mapToPlatformSet(ArrayRef<Triple> Targets) {
   PlatformSet Result;
   for (const auto &Target : Targets)
-    Result.insert(mapToPlatformKind(Target));
+    Result.insert(mapToPlatformType(Target));
   return Result;
 }
 
-StringRef getPlatformName(PlatformKind Platform) {
+StringRef getPlatformName(PlatformType Platform) {
   switch (Platform) {
-  case PlatformKind::unknown:
+  case PLATFORM_UNKNOWN:
     return "unknown";
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     return "macOS";
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     return "iOS";
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     return "tvOS";
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     return "watchOS";
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     return "bridgeOS";
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     return "macCatalyst";
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     return "iOS Simulator";
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     return "tvOS Simulator";
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     return "watchOS Simulator";
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     return "DriverKit";
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
-PlatformKind getPlatformFromName(StringRef Name) {
-  return StringSwitch<PlatformKind>(Name)
-      .Case("macos", PlatformKind::macOS)
-      .Case("ios", PlatformKind::iOS)
-      .Case("tvos", PlatformKind::tvOS)
-      .Case("watchos", PlatformKind::watchOS)
-      .Case("bridgeos", PlatformKind::macOS)
-      .Case("ios-macabi", PlatformKind::macCatalyst)
-      .Case("ios-simulator", PlatformKind::iOSSimulator)
-      .Case("tvos-simulator", PlatformKind::tvOSSimulator)
-      .Case("watchos-simulator", PlatformKind::watchOSSimulator)
-      .Case("driverkit", PlatformKind::driverKit)
-      .Default(PlatformKind::unknown);
+PlatformType getPlatformFromName(StringRef Name) {
+  return StringSwitch<PlatformType>(Name)
+      .Case("macos", PLATFORM_MACOS)
+      .Case("ios", PLATFORM_IOS)
+      .Case("tvos", PLATFORM_TVOS)
+      .Case("watchos", PLATFORM_WATCHOS)
+      .Case("bridgeos", PLATFORM_BRIDGEOS)
+      .Case("ios-macabi", PLATFORM_MACCATALYST)
+      .Case("ios-simulator", PLATFORM_IOSSIMULATOR)
+      .Case("tvos-simulator", PLATFORM_TVOSSIMULATOR)
+      .Case("watchos-simulator", PLATFORM_WATCHOSSIMULATOR)
+      .Case("driverkit", PLATFORM_DRIVERKIT)
+      .Default(PLATFORM_UNKNOWN);
 }
 
-std::string getOSAndEnvironmentName(PlatformKind Platform,
+std::string getOSAndEnvironmentName(PlatformType Platform,
                                     std::string Version) {
   switch (Platform) {
-  case PlatformKind::unknown:
+  case PLATFORM_UNKNOWN:
     return "darwin" + Version;
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     return "macos" + Version;
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     return "ios" + Version;
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     return "tvos" + Version;
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     return "watchos" + Version;
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     return "bridgeos" + Version;
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     return "ios" + Version + "-macabi";
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     return "ios" + Version + "-simulator";
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     return "tvos" + Version + "-simulator";
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     return "watchos" + Version + "-simulator";
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     return "driverkit" + Version;
   }
-  llvm_unreachable("Unknown llvm::MachO::PlatformKind enum");
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/Target.cpp

 namespace llvm {
 namespace MachO {
 
 Expected<Target> Target::create(StringRef TargetValue) {
   auto Result = TargetValue.split('-');
   auto ArchitectureStr = Result.first;
   auto Architecture = getArchitectureFromName(ArchitectureStr);
   auto PlatformStr = Result.second;
-  PlatformKind Platform;
-  Platform = StringSwitch<PlatformKind>(PlatformStr)
-                 .Case("macos", PlatformKind::macOS)
-                 .Case("ios", PlatformKind::iOS)
-                 .Case("tvos", PlatformKind::tvOS)
-                 .Case("watchos", PlatformKind::watchOS)
-                 .Case("bridgeos", PlatformKind::bridgeOS)
-                 .Case("maccatalyst", PlatformKind::macCatalyst)
-                 .Case("ios-simulator", PlatformKind::iOSSimulator)
-                 .Case("tvos-simulator", PlatformKind::tvOSSimulator)
-                 .Case("watchos-simulator", PlatformKind::watchOSSimulator)
-                 .Case("driverkit", PlatformKind::driverKit)
-                 .Default(PlatformKind::unknown);
+  PlatformType Platform;
+  Platform = StringSwitch<PlatformType>(PlatformStr)
+                 .Case("macos", PLATFORM_MACOS)
+                 .Case("ios", PLATFORM_IOS)
+                 .Case("tvos", PLATFORM_TVOS)
+                 .Case("watchos", PLATFORM_WATCHOS)
+                 .Case("bridgeos", PLATFORM_BRIDGEOS)
+                 .Case("maccatalyst", PLATFORM_MACCATALYST)
+                 .Case("ios-simulator", PLATFORM_IOSSIMULATOR)
+                 .Case("tvos-simulator", PLATFORM_TVOSSIMULATOR)
+                 .Case("watchos-simulator", PLATFORM_WATCHOSSIMULATOR)
+                 .Case("driverkit", PLATFORM_DRIVERKIT)
+                 .Default(PLATFORM_UNKNOWN);
 
-  if (Platform == PlatformKind::unknown) {
+  if (Platform == PLATFORM_UNKNOWN) {
     if (PlatformStr.startswith("<") && PlatformStr.endswith(">")) {
       PlatformStr = PlatformStr.drop_front().drop_back();
       unsigned long long RawValue;
       if (!PlatformStr.getAsInteger(10, RawValue))
-        Platform = (PlatformKind)RawValue;
+        Platform = (PlatformType)RawValue;
     }
   }
 
   return Target{Architecture, Platform};
 }
 
 Target::operator std::string() const {
   return (getArchitectureName(Arch) + " (" + getPlatformName(Platform) + ")")

llvm/lib/TextAPI/TextStub.cpp

 
 template <> struct ScalarTraits<Target> {
   static void output(const Target &Value, void *, raw_ostream &OS) {
     OS << Value.Arch << "-";
     switch (Value.Platform) {
     default:
       OS << "unknown";
       break;
-    case PlatformKind::macOS:
+    case PLATFORM_MACOS:
       OS << "macos";
       break;
-    case PlatformKind::iOS:
+    case PLATFORM_IOS:
       OS << "ios";
       break;
-    case PlatformKind::tvOS:
+    case PLATFORM_TVOS:
       OS << "tvos";
       break;
-    case PlatformKind::watchOS:
+    case PLATFORM_WATCHOS:
       OS << "watchos";
       break;
-    case PlatformKind::bridgeOS:
+    case PLATFORM_BRIDGEOS:
       OS << "bridgeos";
       break;
-    case PlatformKind::macCatalyst:
+    case PLATFORM_MACCATALYST:
       OS << "maccatalyst";
       break;
-    case PlatformKind::iOSSimulator:
+    case PLATFORM_IOSSIMULATOR:
       OS << "ios-simulator";
       break;
-    case PlatformKind::tvOSSimulator:
+    case PLATFORM_TVOSSIMULATOR:
       OS << "tvos-simulator";
       break;
-    case PlatformKind::watchOSSimulator:
+    case PLATFORM_WATCHOSSIMULATOR:
       OS << "watchos-simulator";
       break;
-    case PlatformKind::driverKit:
+    case PLATFORM_DRIVERKIT:
       OS << "driverkit";
       break;
     }
   }
 
   static StringRef input(StringRef Scalar, void *, Target &Value) {
     auto Result = Target::create(Scalar);
     if (!Result) {
       consumeError(Result.takeError());
       return "unparsable target";
     }
 
     Value = *Result;
     if (Value.Arch == AK_unknown)
       return "unknown architecture";
-    if (Value.Platform == PlatformKind::unknown)
+    if (Value.Platform == PLATFORM_UNKNOWN)
       return "unknown platform";
 
     return {};
   }
 
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
struct NormalizedTBD {
     // files, but the architectures don't apply to all
     // platforms, specifically to filter out the i386 slice from
     // platform macCatalyst.
     TargetList synthesizeTargets(ArchitectureSet Architectures,
                                  const PlatformSet &Platforms) {
       TargetList Targets;
 
       for (auto Platform : Platforms) {
-        Platform = mapToPlatformKind(Platform, Architectures.hasX86());
+        Platform = mapToPlatformType(Platform, Architectures.hasX86());
 
         for (const auto &&Architecture : Architectures) {
-          if ((Architecture == AK_i386) &&
-              (Platform == PlatformKind::macCatalyst))
+          if ((Architecture == AK_i386) && (Platform == PLATFORM_MACCATALYST))
             continue;
 
           Targets.emplace_back(Architecture, Platform);
         }
       }
       return Targets;
     }
 

llvm/lib/TextAPI/TextStubCommon.cpp

 
 void ScalarTraits<PlatformSet>::output(const PlatformSet &Values, void *IO,
                                        raw_ostream &OS) {
 
   const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
   assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
          "File type is not set in context");
 
-  if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PlatformKind::macOS) &&
-      Values.count(PlatformKind::macCatalyst)) {
+  if (Ctx && Ctx->FileKind == TBD_V3 && Values.count(PLATFORM_MACOS) &&
+      Values.count(PLATFORM_MACCATALYST)) {
     OS << "zippered";
     return;
   }
 
   assert(Values.size() == 1U);
   switch (*Values.begin()) {
   default:
     llvm_unreachable("unexpected platform");
     break;
-  case PlatformKind::macOS:
+  case PLATFORM_MACOS:
     OS << "macosx";
     break;
-  case PlatformKind::iOSSimulator:
+  case PLATFORM_IOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::iOS:
+  case PLATFORM_IOS:
     OS << "ios";
     break;
-  case PlatformKind::watchOSSimulator:
+  case PLATFORM_WATCHOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::watchOS:
+  case PLATFORM_WATCHOS:
     OS << "watchos";
     break;
-  case PlatformKind::tvOSSimulator:
+  case PLATFORM_TVOSSIMULATOR:
     LLVM_FALLTHROUGH;
-  case PlatformKind::tvOS:
+  case PLATFORM_TVOS:
     OS << "tvos";
     break;
-  case PlatformKind::bridgeOS:
+  case PLATFORM_BRIDGEOS:
     OS << "bridgeos";
     break;
-  case PlatformKind::macCatalyst:
+  case PLATFORM_MACCATALYST:
     OS << "iosmac";
     break;
-  case PlatformKind::driverKit:
+  case PLATFORM_DRIVERKIT:
     OS << "driverkit";
     break;
   }
 }
 
 StringRef ScalarTraits<PlatformSet>::input(StringRef Scalar, void *IO,
                                            PlatformSet &Values) {
   const auto *Ctx = reinterpret_cast<TextAPIContext *>(IO);
   assert((!Ctx || Ctx->FileKind != FileType::Invalid) &&
          "File type is not set in context");
 
   if (Scalar == "zippered") {
     if (Ctx && Ctx->FileKind == FileType::TBD_V3) {
-      Values.insert(PlatformKind::macOS);
-      Values.insert(PlatformKind::macCatalyst);
+      Values.insert(PLATFORM_MACOS);
+      Values.insert(PLATFORM_MACCATALYST);
       return {};
     }
     return "invalid platform";
   }
 
-  auto Platform = StringSwitch<PlatformKind>(Scalar)
-                      .Case("unknown", PlatformKind::unknown)
-                      .Case("macosx", PlatformKind::macOS)
-                      .Case("ios", PlatformKind::iOS)
-                      .Case("watchos", PlatformKind::watchOS)
-                      .Case("tvos", PlatformKind::tvOS)
-                      .Case("bridgeos", PlatformKind::bridgeOS)
-                      .Case("iosmac", PlatformKind::macCatalyst)
-                      .Default(PlatformKind::unknown);
+  auto Platform = StringSwitch<PlatformType>(Scalar)
+                      .Case("macosx", PLATFORM_MACOS)
+                      .Case("ios", PLATFORM_IOS)
+                      .Case("watchos", PLATFORM_WATCHOS)
+                      .Case("tvos", PLATFORM_TVOS)
+                      .Case("bridgeos", PLATFORM_BRIDGEOS)
+                      .Case("iosmac", PLATFORM_MACCATALYST)
+                      .Default(PLATFORM_UNKNOWN);
 
-  if (Platform == PlatformKind::macCatalyst)
+  if (Platform == PLATFORM_MACCATALYST)
     if (Ctx && Ctx->FileKind != FileType::TBD_V3)
       return "invalid platform";
 
-  if (Platform == PlatformKind::unknown)
+  if (Platform == PLATFORM_UNKNOWN)
     return "unknown platform";
 
   Values.insert(Platform);
   return {};
 }
 
 QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) {
   return QuotingType::None;

 }
 StringRef ScalarTraits<UUID>::input(StringRef Scalar, void *, UUID &Value) {
   auto Split = Scalar.split(':');
   auto Arch = Split.first.trim();
   auto UUID = Split.second.trim();
   if (UUID.empty())
     return "invalid uuid string pair";
   Value.second = std::string(UUID);
-  Value.first = Target{getArchitectureFromName(Arch), PlatformKind::unknown};
+  Value.first = Target{getArchitectureFromName(Arch), PLATFORM_UNKNOWN};
   return {};
 }
 
 QuotingType ScalarTraits<UUID>::mustQuote(StringRef) {
   return QuotingType::Single;
 }
 
 } // end namespace yaml.
 } // end namespace llvm.

llvm/tools/llvm-ifs/llvm-ifs.cpp

EC.addError(createStringError(errc::not_supported,
               "ReadInputFile");
   EC.escalateToFatal();
   return EC.makeError();
 }
 
 static int writeTbdStub(const Triple &T, const std::vector<IFSSymbol> &Symbols,
                         const StringRef Format, raw_ostream &Out) {
 
-  auto PlatformKindOrError =
-      [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {
+  auto PlatformTypeOrError =
+      [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformType> {
     if (T.isMacOSX())
-      return llvm::MachO::PlatformKind::macOS;
+      return llvm::MachO::PLATFORM_MACOS;
     if (T.isTvOS())
-      return llvm::MachO::PlatformKind::tvOS;
+      return llvm::MachO::PLATFORM_TVOS;
     if (T.isWatchOS())
-      return llvm::MachO::PlatformKind::watchOS;
+      return llvm::MachO::PLATFORM_WATCHOS;
     // Note: put isiOS last because tvOS and watchOS are also iOS according
     // to the Triple.
     if (T.isiOS())
-      return llvm::MachO::PlatformKind::iOS;
+      return llvm::MachO::PLATFORM_IOS;
 
     return createStringError(errc::not_supported, "Invalid Platform.\n");
   }(T);
 
-  if (!PlatformKindOrError)
+  if (!PlatformTypeOrError)
     return -1;
 
-  PlatformKind Plat = PlatformKindOrError.get();
+  PlatformType Plat = PlatformTypeOrError.get();
   TargetList Targets({Target(llvm::MachO::mapToArchitecture(T), Plat)});
 
   InterfaceFile File;
   File.setFileType(FileType::TBD_V3); // Only supporting v3 for now.
   File.addTargets(Targets);
 
   for (const auto &Symbol : Symbols) {
     auto Name = Symbol.Name;

llvm/tools/llvm-tapi-diff/DiffEngine.cpp

std::string SymScalar::stringifySymbolFlag(MachO::SymbolFlags Flag) {
   case MachO::SymbolFlags::Rexported:
     return "Reexported";
   }
   llvm_unreachable("Unknown llvm::MachO::SymbolFlags enum");
 }
 
 void SymScalar::print(raw_ostream &OS, std::string Indent, MachO::Target Targ) {
   if (Val->getKind() == MachO::SymbolKind::ObjectiveCClass) {
-    if (Targ.Arch == MachO::AK_i386 &&
-        Targ.Platform == MachO::PlatformKind::macOS) {
+    if (Targ.Arch == MachO::AK_i386 && Targ.Platform == MachO::PLATFORM_MACOS) {
       OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
          << ObjC1ClassNamePrefix << Val->getName()
          << getFlagString(Val->getFlags()) << "\n";
       return;
     }
     OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
        << ObjC2ClassNamePrefix << Val->getName()
        << getFlagString(Val->getFlags()) << "\n";

llvm/unittests/TextAPI/TextStubV1Tests.cpp

static const char TBDv1File1[] =
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1File1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
static const char TBDv1File2[] = "--- !tapi-tbd-v1\n"
                                    "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1File2, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
static const char TBDv1File3[] =
       "    symbols:         [ '_OBJC_EHTYPE_$_Class1' ]\n"
       "    objc-classes:    [ _Class1 ]\n"
       "    objc-ivars:      [ _Class1._ivar1 ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V1);
   File.addTargets(Targets);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setSwiftABIVersion(5);
   File.setObjCConstraint(ObjCConstraintType::Retain_Release);
   File.addAllowableClient("clientA", Targets[1]);
static const char TBDv1PlatformMacOS[] = "---\n"
                                            "archs: [ x86_64 ]\n"
                                            "platform: macosx\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv1, Platform_iOS) {
   static const char TBDv1PlatformiOS[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv1, Platform_watchOS) {
   static const char TBDv1PlatformWatchOS[] = "---\n"
                                              "archs: [ armv7k ]\n"
                                              "platform: watchos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformWatchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv1, Platform_tvOS) {
   static const char TBDv1PlatformtvOS[] = "---\n"
                                           "archs: [ arm64 ]\n"
                                           "platform: tvos\n"
                                           "install-name: Test.dylib\n"
                                           "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv1, Platform_bridgeOS) {
   static const char TBDv1BridgeOS[] = "---\n"
                                       "archs: [ armv7k ]\n"
                                       "platform: bridgeos\n"
                                       "install-name: Test.dylib\n"
                                       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv1BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv1, Swift_1_0) {
   static const char TBDv1Swift1[] = "---\n"

llvm/unittests/TextAPI/TextStubV2Tests.cpp

static const char TBDv2File1[] =
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2File1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
static const char TBDv2File2[] =
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2File2, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
static const char TBDv2File3[] =
       "    symbols:         [ '_OBJC_EHTYPE_$_Class1' ]\n"
       "    objc-classes:    [ _Class1 ]\n"
       "    objc-ivars:      [ _Class1._ivar1 ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V2);
   File.addTargets(Targets);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
   File.setApplicationExtensionSafe();
   File.setSwiftABIVersion(5);
static const char TBDv2PlatformMacOS[] = "--- !tapi-tbd-v2\n"
                                            "platform: macosx\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv2, Platform_iOS) {
   static const char TBDv2PlatformiOS[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv2, Platform_watchOS) {
   static const char TBDv2PlatformWatchOS[] = "--- !tapi-tbd-v2\n"
                                              "archs: [ armv7k ]\n"
                                              "platform: watchos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformWatchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv2, Platform_tvOS) {
   static const char TBDv2PlatformtvOS[] = "--- !tapi-tbd-v2\n"
                                           "archs: [ arm64 ]\n"
                                           "platform: tvos\n"
                                           "install-name: Test.dylib\n"
                                           "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv2, Platform_bridgeOS) {
   static const char TBDv2BridgeOS[] = "--- !tapi-tbd-v2\n"
                                       "archs: [ armv7k ]\n"
                                       "platform: bridgeos\n"
                                       "install-name: Test.dylib\n"
                                       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv2BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 }
 
 TEST(TBDv2, Swift_1_0) {
   static const char TBDv2Swift1[] = "--- !tapi-tbd-v2\n"

llvm/unittests/TextAPI/TextStubV3Tests.cpp

static const char TBDv3File1[] =
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3File1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PlatformKind::unknown),
+  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                   "00000000-0000-0000-0000-000000000000"},
-                 {Target(AK_arm64, PlatformKind::unknown),
+                 {Target(AK_arm64, PLATFORM_UNKNOWN),
                   "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
TEST(TBDv3, ReadMultipleDocuments) {
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3Inlines, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(File->documents().size(), 1U);
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
-  UUIDs Uuids = {{Target(AK_armv7, PlatformKind::unknown),
+  UUIDs Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                   "00000000-0000-0000-0000-000000000000"},
-                 {Target(AK_arm64, PlatformKind::unknown),
+                 {Target(AK_arm64, PLATFORM_UNKNOWN),
                   "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
static const char TBDv3File3[] =
       "    objc-classes:    [ Class1 ]\n"
       "    objc-eh-types:   [ Class1 ]\n"
       "    objc-ivars:      [ Class1._ivar1 ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64)
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V3);
   File.addTargets(Targets);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
   File.setApplicationExtensionSafe();
   File.setSwiftABIVersion(5);
static const char TBDv3Inlines[] =
       "exports:\n"
       "  - archs:           [ i386 ]\n"
       "    symbols:         [ _sym3, _sym4 ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets;
   for (auto &&arch : AK_i386 | AK_x86_64) {
-    Targets.emplace_back(Target(arch, PlatformKind::macOS));
-    Targets.emplace_back(Target(arch, PlatformKind::macCatalyst));
+    Targets.emplace_back(Target(arch, PLATFORM_MACOS));
+    Targets.emplace_back(Target(arch, PLATFORM_MACCATALYST));
   }
   File.addTargets(Targets);
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V3);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
   File.setApplicationExtensionSafe();
   File.setSwiftABIVersion(5);
   File.setObjCConstraint(ObjCConstraintType::Retain_Release);
   File.addAllowableClient("clientA", Targets[2]);
   File.addReexportedLibrary("/usr/lib/libbar.dylib", Targets[2]);
   File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", Targets);
   File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", Targets,
                  SymbolFlags::WeakDefined);
   File.addSymbol(SymbolKind::GlobalSymbol, "_symA", Targets,
                  SymbolFlags::ThreadLocalValue);
   File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Targets);
   File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1", Targets);
   File.addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
                  Targets);
 
   // Inline document
   InterfaceFile Document;
-  Targets = {Target(AK_i386, PlatformKind::macOS)};
+  Targets = {Target(AK_i386, PLATFORM_MACOS)};
   Document.addTargets(Targets);
   Document.setPath("libbar.dylib");
   Document.setInstallName("/usr/lib/libbar.dylib");
   Document.setFileType(FileType::TBD_V3);
   Document.setTwoLevelNamespace();
   Document.setApplicationExtensionSafe();
   Document.setSwiftABIVersion(5);
   Document.addSymbol(SymbolKind::GlobalSymbol, "_sym3", Targets);
static const char TBDv3PlatformMacOS[] = "--- !tapi-tbd-v3\n"
                                            "archs: [ x86_64 ]\n"
                                            "platform: macosx\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformMacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macOS;
+  auto Platform = PLATFORM_MACOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformMacOS),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_iOS) {
   static const char TBDv3PlatformiOS[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformiOS), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_watchOS) {
   static const char TBDv3watchOS[] = "--- !tapi-tbd-v3\n"
                                      "archs: [ armv7k ]\n"
                                      "platform: watchos\n"
                                      "install-name: Test.dylib\n"
                                      "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3watchOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOS;
+  auto Platform = PLATFORM_WATCHOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3watchOS), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_tvOS) {
   static const char TBDv3PlatformtvOS[] = "--- !tapi-tbd-v3\n"
                                           "archs: [ arm64 ]\n"
                                           "platform: tvos\n"
                                           "install-name: Test.dylib\n"
                                           "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformtvOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::tvOS;
+  auto Platform = PLATFORM_TVOS;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_FALSE(WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformtvOS),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_bridgeOS) {
   static const char TBDv3BridgeOS[] = "--- !tapi-tbd-v3\n"
                                       "archs: [ armv7k ]\n"
                                       "platform: bridgeos\n"
                                       "install-name: Test.dylib\n"
                                       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3BridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::bridgeOS;
+  auto Platform = PLATFORM_BRIDGEOS;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3BridgeOS), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_macCatalyst) {
   static const char TBDv3PlatformiOSmac[] = "--- !tapi-tbd-v3\n"
                                             "archs: [ armv7k ]\n"
                                             "platform: iosmac\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOSmac, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::macCatalyst;
+  auto Platform = PLATFORM_MACCATALYST;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
TEST(TBDv3, Platform_zippered) {
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformZippered, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
 
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_MACOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
       EXPECT_EQ(Platforms.count(Platform), 1U);
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformZippered),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_iOSSim) {
   static const char TBDv3PlatformiOSsim[] = "--- !tapi-tbd-v3\n"
                                             "archs: [ x86_64 ]\n"
                                             "platform: ios\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformiOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::iOSSimulator;
+  auto Platform = PLATFORM_IOSSIMULATOR;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformiOSsim),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_watchOSSim) {
   static const char TBDv3watchOSsim[] = "--- !tapi-tbd-v3\n"
                                         "archs: [ x86_64 ]\n"
                                         "platform: watchos\n"
                                         "install-name: Test.dylib\n"
                                         "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3watchOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
-  auto Platform = PlatformKind::watchOSSimulator;
+  auto Platform = PLATFORM_WATCHOSSIMULATOR;
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3watchOSsim), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Platform_tvOSSim) {
   static const char TBDv3PlatformtvOSsim[] = "--- !tapi-tbd-v3\n"
                                              "archs: [ x86_64 ]\n"
                                              "platform: tvos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3PlatformtvOSsim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::tvOSSimulator;
+  auto Platform = PLATFORM_TVOSSIMULATOR;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv3PlatformtvOSsim),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv3, Arch_arm64e) {
   static const char TBDv3ArchArm64e[] = "--- !tapi-tbd-v3\n"
                                         "archs: [ arm64, arm64e ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv3ArchArm64e, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
-  auto Platform = PlatformKind::iOS;
+  auto Platform = PLATFORM_IOS;
   auto Archs = AK_arm64 | AK_arm64e;
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(Archs, File->getArchitectures());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
TEST(TBDv3, InterfaceInequality) {
   EXPECT_TRUE(!!ResultA);
   InterfaceFile FileA = std::move(*ResultA.get());
   Expected<TBDFile> ResultB =
       TextAPIReader::get(MemoryBufferRef(TBDv3File, "TestB.tbd"));
   EXPECT_TRUE(!!ResultB);
   InterfaceFile FileB = std::move(*ResultB.get());
 
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addTarget(Target(AK_x86_64, PlatformKind::iOS));
+    File->addTarget(Target(AK_x86_64, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setCurrentVersion(PackedVersion(1, 2, 3));
     File->setCompatibilityVersion(PackedVersion(1, 0, 0));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(
       FileA, FileB, [](InterfaceFile *File) { File->setSwiftABIVersion(5); }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setTwoLevelNamespace(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(
       FileA, FileB, [](InterfaceFile *File) { File->setInstallAPI(true); }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setApplicationExtensionSafe(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addParentUmbrella(Target(AK_armv7, PlatformKind::iOS), "Umbrella.dylib");
+    File->addParentUmbrella(Target(AK_armv7, PLATFORM_IOS), "Umbrella.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addAllowableClient("ClientA", Target(AK_armv7, PlatformKind::iOS));
+    File->addAllowableClient("ClientA", Target(AK_armv7, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
-                              Target(AK_armv7, PlatformKind::iOS));
+                               Target(AK_armv7, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addSymbol(SymbolKind::GlobalSymbol, "_symA", {Target(AK_arm64, PlatformKind::iOS)});
+    File->addSymbol(SymbolKind::GlobalSymbol, "_symA",
+                    {Target(AK_arm64, PLATFORM_IOS)});
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     InterfaceFile Document;
-    Document.addTargets(TargetList{Target(AK_armv7, PlatformKind::iOS),
-                      Target(AK_arm64, PlatformKind::iOS)});
+    Document.addTargets(TargetList{Target(AK_armv7, PLATFORM_IOS),
+                                   Target(AK_arm64, PLATFORM_IOS)});
     Document.setInstallName("/System/Library/Frameworks/A.framework/A");
     File->addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
   }));
 }
 
 } // namespace TBDv3

llvm/unittests/TextAPI/TextStubV4Tests.cpp

TEST(TBDv4, ReadFile) {
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   PlatformSet Platforms;
   Platforms.insert(getPlatformFromName("macos"));
   Platforms.insert(getPlatformFromName("ios"));
   auto Archs = AK_i386 | AK_x86_64;
   TargetList Targets = {
-      Target(AK_i386, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::iOS),
+      Target(AK_i386, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_IOS),
   };
   UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                  {Targets[1], "11111111-1111-1111-1111-111111111111"},
                  {Targets[2], "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(uuids, File->uuids());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
static const char TBDv4Inlines[] =
       "    objc-classes: []\n"
       "    objc-eh-types: []\n"
       "    objc-ivars: []\n"
       "    weak-symbols: []\n"
       "    thread-local-symbols: []\n"
       "...\n";
 
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_MACOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   ArchitectureSet Archs = AK_i386 | AK_x86_64;
   TargetList Targets;
   for (auto &&Arch : Archs)
     for (auto &&Platform : Platforms)
       Targets.emplace_back(Target(Arch, Platform));
   UUIDs Uuids = {
       {Targets[0], "00000000-0000-0000-0000-000000000000"},
       {Targets[1], "00000000-0000-0000-0000-000000000002"},
InterfaceFileRef reexport("/System/Library/Frameworks/A.framework/A",
                             {Targets[0], Targets[2]});
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
   EXPECT_TRUE(File->symbols().empty());
 
   // Check Inlined Document
   Targets.clear();
   Uuids.clear();
-  PlatformKind Platform = PlatformKind::macOS;
+  PlatformType Platform = PLATFORM_MACOS;
   for (auto &&Arch : Archs)
     Targets.emplace_back(Target(Arch, Platform));
   Uuids = {
       {Targets[0], "20000000-0000-0000-0000-000000000000"},
       {Targets[1], "21111111-1111-1111-1111-111111111111"},
   };
 
   TBDReexportFile Document = File->documents().front();
static const char TBDv4File[] =
       "    objc-classes:    [ Class1 ]\n"
       "    weak-symbols:    [ _symC ]\n"
       "  - targets:         [ x86_64-ios-simulator ]\n"
       "    symbols:         [ _symB ]\n"
       "...\n";
 
   InterfaceFile File;
   TargetList Targets = {
-      Target(AK_i386, PlatformKind::macOS),
-      Target(AK_x86_64, PlatformKind::iOSSimulator),
+      Target(AK_i386, PLATFORM_MACOS),
+      Target(AK_x86_64, PLATFORM_IOSSIMULATOR),
   };
   UUIDs uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
                  {Targets[1], "11111111-1111-1111-1111-111111111111"}};
   File.setInstallName("Umbrella.framework/Umbrella");
   File.setFileType(FileType::TBD_V4);
   File.addTargets(Targets);
   File.addUUID(uuids[0].first, uuids[0].second);
   File.addUUID(uuids[1].first, uuids[1].second);
static const char TBDv4Inlines[] =
       "  - targets:         [ i386-maccatalyst, x86_64-maccatalyst ]\n"
       "    symbols:         [ _symA ]\n"
       "    objc-classes:    [ Class1 ]\n"
       "  - targets:         [ x86_64-maccatalyst ]\n"
       "    symbols:         [ _symAB ]\n"
       "...\n";
 
   InterfaceFile File;
-  PlatformKind Platform = PlatformKind::macCatalyst;
+  PlatformType Platform = PLATFORM_MACCATALYST;
   TargetList Targets = {
       Target(AK_i386, Platform),
       Target(AK_x86_64, Platform),
   };
   UUIDs Uuids = {{Targets[0], "00000000-0000-0000-0000-000000000002"},
                  {Targets[1], "11111111-1111-1111-1111-111111111112"}};
   File.setInstallName("/System/Library/Frameworks/Umbrella.framework/Umbrella");
   File.setFileType(FileType::TBD_V4);
static const char TBDv4MultipleTargets[] =
       "targets: [ i386-maccatalyst, x86_64-tvos, arm64-ios ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4MultipleTargets, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::macCatalyst);
-  Platforms.insert(PlatformKind::tvOS);
-  Platforms.insert(PlatformKind::iOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
+  Platforms.insert(PLATFORM_TVOS);
+  Platforms.insert(PLATFORM_IOS);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_x86_64 | AK_arm64 | AK_i386, File->getArchitectures());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
     EXPECT_EQ(Platforms.count(Platform), 1U);
 
   SmallString<4096> Buffer;
static const char TBDv4TargetsSameArch[] =
       "targets: [ x86_64-tvos , x86_64-maccatalyst ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4TargetsSameArch, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   PlatformSet Platforms;
-  Platforms.insert(PlatformKind::tvOS);
-  Platforms.insert(PlatformKind::macCatalyst);
+  Platforms.insert(PLATFORM_TVOS);
+  Platforms.insert(PLATFORM_MACCATALYST);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(Platforms.size(), File->getPlatforms().size());
   for (auto Platform : File->getPlatforms())
     EXPECT_EQ(Platforms.count(Platform), 1U);
 
   SmallString<4096> Buffer;
TEST(TBDv4, MultipleTargetsSamePlatform) {
 
   Expected<TBDFile> Result = TextAPIReader::get(
       MemoryBufferRef(TBDv4MultipleTargetsSamePlatform, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(AK_arm64 | AK_armv7k, File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4MultipleTargetsSamePlatform),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_maccatalyst) {
   static const char TBDv4TargetMacCatalyst[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  x86_64-maccatalyst ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4TargetMacCatalyst, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::macCatalyst, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_MACCATALYST, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4TargetMacCatalyst),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_ios) {
   static const char TBDv4Targetx86iOS[] = "--- !tapi-tbd\n"
                                           "tbd-version: 4\n"
                                           "targets: [  x86_64-ios ]\n"
                                           "install-name: Test.dylib\n"
                                           "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4Targetx86iOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4Targetx86iOS),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_arm_bridgeOS) {
   static const char TBDv4PlatformBridgeOS[] = "--- !tapi-tbd\n"
                                               "tbd-version: 4\n"
                                               "targets: [  armv7k-bridgeos ]\n"
                                               "install-name: Test.dylib\n"
                                               "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4PlatformBridgeOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::bridgeOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_BRIDGEOS, *File->getPlatforms().begin());
   EXPECT_EQ(ArchitectureSet(AK_armv7k), File->getArchitectures());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4PlatformBridgeOS),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_arm_iOS) {
   static const char TBDv4ArchArm64e[] = "--- !tapi-tbd\n"
                                         "tbd-version: 4\n"
                                         "targets: [  arm64e-ios ]\n"
                                         "install-name: Test.dylib\n"
                                         "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4ArchArm64e, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOS, *File->getPlatforms().begin());
   EXPECT_EQ(ArchitectureSet(AK_arm64e), File->getArchitectures());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4ArchArm64e), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_macos) {
   static const char TBDv4Targetx86MacOS[] = "--- !tapi-tbd\n"
                                             "tbd-version: 4\n"
                                             "targets: [  x86_64-macos ]\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4Targetx86MacOS, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::macOS, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_MACOS, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4Targetx86MacOS),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_ios_simulator) {
   static const char TBDv4Targetx86iOSSim[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  x86_64-ios-simulator  ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4Targetx86iOSSim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::iOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_IOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4Targetx86iOSSim),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_x86_tvos_simulator) {
   static const char TBDv4x86tvOSSim[] = "--- !tapi-tbd\n"
                                         "tbd-version: 4\n"
                                         "targets: [  x86_64-tvos-simulator  ]\n"
                                         "install-name: Test.dylib\n"
                                         "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4x86tvOSSim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_x86_64), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::tvOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_TVOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4x86tvOSSim), stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_i386_watchos_simulator) {
   static const char TBDv4i386watchOSSim[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [  i386-watchos-simulator  ]\n"
       "install-name: Test.dylib\n"
       "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4i386watchOSSim, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::watchOSSimulator, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_WATCHOSSIMULATOR, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4i386watchOSSim),
             stripWhitespace(Buffer.c_str()));
 }
 
 TEST(TBDv4, Target_i386_driverkit) {
   static const char TBDv4i386DriverKit[] = "--- !tapi-tbd\n"
                                            "tbd-version: 4\n"
                                            "targets: [  i386-driverkit  ]\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4i386DriverKit, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(ArchitectureSet(AK_i386), File->getArchitectures());
   EXPECT_EQ(File->getPlatforms().size(), 1U);
-  EXPECT_EQ(PlatformKind::driverKit, *File->getPlatforms().begin());
+  EXPECT_EQ(PLATFORM_DRIVERKIT, *File->getPlatforms().begin());
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error WriteResult = TextAPIWriter::writeToStream(OS, *File);
   EXPECT_TRUE(!WriteResult);
   EXPECT_EQ(stripWhitespace(TBDv4i386DriverKit),
             stripWhitespace(Buffer.c_str()));
 }
TEST(TBDv4, InterfaceInequality) {
   EXPECT_TRUE(!!ResultA);
   InterfaceFile FileA = std::move(*ResultA.get());
   Expected<TBDFile> ResultB =
       TextAPIReader::get(MemoryBufferRef(TBDv4File, "TestB.tbd"));
   EXPECT_TRUE(!!ResultB);
   InterfaceFile FileB = std::move(*ResultB.get());
 
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addTarget(Target(AK_x86_64, PlatformKind::iOS));
+    File->addTarget(Target(AK_x86_64, PLATFORM_IOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setCurrentVersion(PackedVersion(1, 2, 3));
     File->setCompatibilityVersion(PackedVersion(1, 0, 0));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(
       FileA, FileB, [](InterfaceFile *File) { File->setSwiftABIVersion(5); }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setTwoLevelNamespace(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(
       FileA, FileB, [](InterfaceFile *File) { File->setInstallAPI(true); }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->setApplicationExtensionSafe(false);
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addParentUmbrella(Target(AK_x86_64, PlatformKind::macOS), "System.dylib");
+    File->addParentUmbrella(Target(AK_x86_64, PLATFORM_MACOS), "System.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addAllowableClient("ClientA", Target(AK_i386, PlatformKind::macOS));
+    File->addAllowableClient("ClientA", Target(AK_i386, PLATFORM_MACOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
-                               Target(AK_i386, PlatformKind::macOS));
+                               Target(AK_i386, PLATFORM_MACOS));
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
-    File->addSymbol(SymbolKind::GlobalSymbol, "_symA", {Target(AK_x86_64, PlatformKind::macOS)});
+    File->addSymbol(SymbolKind::GlobalSymbol, "_symA",
+                    {Target(AK_x86_64, PLATFORM_MACOS)});
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     InterfaceFile Document;
-    Document.addTargets(TargetList {Target(AK_i386, PlatformKind::macOS),
-                      Target(AK_x86_64, PlatformKind::macOS)});
+    Document.addTargets(TargetList{Target(AK_i386, PLATFORM_MACOS),
+                                   Target(AK_x86_64, PLATFORM_MACOS)});
     Document.setInstallName("/System/Library/Frameworks/A.framework/A");
     File->addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
   }));
 }
 
 } // end namespace TBDv4