[TextAPI] Remove TBD file attributes that aren't used anymore.

[cishida]

Summary

UUID's & installapi flag are no longer useful in recent apple linker/tapi.
The reason for removing them is that these are attributes that record
how a library was built but not really about the library itself. TBD
files now only track information this is important as link time
dependencies.

[ributzka]

LGTM. Thank you Cyndy for cleaning this up.

[cishida]

Add llvm-tapi-diff changes

llvm/include/llvm/TextAPI/InterfaceFile.h

public:
   /// Set the Objective-C constraint.
   void setObjCConstraint(ObjCConstraintType Constraint) {
     ObjcConstraint = Constraint;
   }
 
   /// Get the Objective-C constraint.
   ObjCConstraintType getObjCConstraint() const { return ObjcConstraint; }
 
-  /// Specify if this file was generated during InstallAPI (or not).
-  void setInstallAPI(bool V = true) { IsInstallAPI = V; }
-
-  /// Check if this file was generated during InstallAPI.
-  bool isInstallAPI() const { return IsInstallAPI; }
-
   /// Set the parent umbrella frameworks.
   /// \param Target_ The target applicable to Parent
   /// \param Parent  The name of Parent
   void addParentUmbrella(const Target &Target_, StringRef Parent);
 
   /// Get the list of Parent Umbrella frameworks.
   ///
   /// \return Returns a list of target information and install name of parent
public:
 
   /// Get the list of re-exported libraries.
   ///
   /// \return Returns a list of re-exported libraries.
   const std::vector<InterfaceFileRef> &reexportedLibraries() const {
     return ReexportedLibraries;
   }
 
-  /// Add an Target/UUID pair.
-  ///
-  /// \param Target The target triple for which this applies.
-  /// \param UUID The UUID of the library for the specified architecture.
-  void addUUID(const Target &Target, StringRef UUID);
-
-  /// Add an Target/UUID pair.
-  ///
-  /// \param Target The target triple for which this applies.
-  /// \param UUID The UUID of the library for the specified architecture.
-  void addUUID(const Target &Target, uint8_t UUID[16]);
-
-  /// Get the list of Target/UUID pairs.
-  ///
-  /// \return Returns a list of Target/UUID pairs.
-  const std::vector<std::pair<Target, std::string>> &uuids() const {
-    return UUIDs;
-  }
-
   /// Add a library for inlining to top level library.
   ///
   ///\param Document The library to inline with top level library.
   void addDocument(std::shared_ptr<InterfaceFile> &&Document);
 
   /// Returns the pointer to parent document if exists or nullptr otherwise.
   InterfaceFile *getParent() const { return Parent; }
 
public:
   const_filtered_symbol_range reexports() const {
     return SymbolsSet->reexports();
   };
   const_filtered_symbol_range undefineds() const {
     return SymbolsSet->undefineds();
   };
 
   /// The equality is determined by attributes that impact linking
-  /// compatibilities. UUIDs, Path, & FileKind are irrelevant since these by
+  /// compatibilities. Path, & FileKind are irrelevant since these by
   /// itself should not impact linking.
   /// This is an expensive operation.
   bool operator==(const InterfaceFile &O) const;
 
   bool operator!=(const InterfaceFile &O) const { return !(*this == O); }
 
 private:
   llvm::BumpPtrAllocator Allocator;
private:
   std::string Path;
   FileType FileKind{FileType::Invalid};
   std::string InstallName;
   PackedVersion CurrentVersion;
   PackedVersion CompatibilityVersion;
   uint8_t SwiftABIVersion{0};
   bool IsTwoLevelNamespace{false};
   bool IsAppExtensionSafe{false};
-  bool IsInstallAPI{false};
   ObjCConstraintType ObjcConstraint = ObjCConstraintType::None;
   std::vector<std::pair<Target, std::string>> ParentUmbrellas;
   std::vector<InterfaceFileRef> AllowableClients;
   std::vector<InterfaceFileRef> ReexportedLibraries;
   std::vector<std::shared_ptr<InterfaceFile>> Documents;
-  std::vector<std::pair<Target, std::string>> UUIDs;
   std::vector<std::pair<Target, std::string>> RPaths;
   std::unique_ptr<SymbolSet> SymbolsSet;
   InterfaceFile *Parent = nullptr;
 };
 
 // Keep containers that hold InterfaceFileRefs in sorted order and uniqued.
 template <typename C>
 typename C::iterator addEntry(C &Container, StringRef InstallName) {

llvm/lib/TextAPI/InterfaceFile.cpp

void InterfaceFile::addRPath(const Target &InputTarget, StringRef RPath) {
   if ((Iter != RPaths.end()) && !(InputTarget < Iter->first)) {
     Iter->second = std::string(RPath);
     return;
   }
 
   RPaths.emplace(Iter, InputTarget, std::string(RPath));
 }
 
-void InterfaceFile::addUUID(const Target &Target_, StringRef UUID) {
-  auto Iter = lower_bound(UUIDs, Target_,
-                          [](const std::pair<Target, std::string> &LHS,
-                             Target RHS) { return LHS.first < RHS; });
-
-  if ((Iter != UUIDs.end()) && !(Target_ < Iter->first)) {
-    Iter->second = std::string(UUID);
-    return;
-  }
-
-  UUIDs.emplace(Iter, Target_, std::string(UUID));
-}
-
-void InterfaceFile::addUUID(const Target &Target, uint8_t UUID[16]) {
-  std::stringstream Stream;
-  for (unsigned i = 0; i < 16; ++i) {
-    if (i == 4 || i == 6 || i == 8 || i == 10)
-      Stream << '-';
-    Stream << std::setfill('0') << std::setw(2) << std::uppercase << std::hex
-           << static_cast<int>(UUID[i]);
-  }
-  addUUID(Target, Stream.str());
-}
-
 void InterfaceFile::addTarget(const Target &Target) {
   addEntry(Targets, Target);
 }
 
 InterfaceFile::const_filtered_target_range
 InterfaceFile::targets(ArchitectureSet Archs) const {
   std::function<bool(const Target &)> fn = [Archs](const Target &Target_) {
     return Archs.has(Target_.Arch);
if ((CurrentVersion != O.CurrentVersion) ||
       (CompatibilityVersion != O.CompatibilityVersion))
     return false;
   if (SwiftABIVersion != O.SwiftABIVersion)
     return false;
   if (IsTwoLevelNamespace != O.IsTwoLevelNamespace)
     return false;
   if (IsAppExtensionSafe != O.IsAppExtensionSafe)
     return false;
-  if (IsInstallAPI != O.IsInstallAPI)
-    return false;
   if (ParentUmbrellas != O.ParentUmbrellas)
     return false;
   if (AllowableClients != O.AllowableClients)
     return false;
   if (ReexportedLibraries != O.ReexportedLibraries)
     return false;
   if (*SymbolsSet != *O.SymbolsSet)
     return false;

llvm/lib/TextAPI/TextStub.cpp

template <> struct ScalarTraits<Target> {
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 template <> struct MappingTraits<const InterfaceFile *> {
   struct NormalizedTBD {
     explicit NormalizedTBD(IO &IO) {}
     NormalizedTBD(IO &IO, const InterfaceFile *&File) {
       Architectures = File->getArchitectures();
-      UUIDs = File->uuids();
       Platforms = File->getPlatforms();
       InstallName = File->getInstallName();
       CurrentVersion = PackedVersion(File->getCurrentVersion());
       CompatibilityVersion = PackedVersion(File->getCompatibilityVersion());
       SwiftABIVersion = File->getSwiftABIVersion();
       ObjCConstraint = File->getObjCConstraint();
 
       Flags = TBDFlags::None;
       if (!File->isApplicationExtensionSafe())
         Flags |= TBDFlags::NotApplicationExtensionSafe;
 
       if (!File->isTwoLevelNamespace())
         Flags |= TBDFlags::FlatNamespace;
 
-      if (File->isInstallAPI())
-        Flags |= TBDFlags::InstallAPI;
-
       if (!File->umbrellas().empty())
         ParentUmbrella = File->umbrellas().begin()->second;
 
       std::set<ArchitectureSet> ArchSet;
       for (const auto &Library : File->allowableClients())
         ArchSet.insert(Library.getArchitectures());
 
       for (const auto &Library : File->reexportedLibraries())
struct NormalizedTBD {
     const InterfaceFile *denormalize(IO &IO) {
       auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
       assert(Ctx);
 
       auto *File = new InterfaceFile;
       File->setPath(Ctx->Path);
       File->setFileType(Ctx->FileKind);
       File->addTargets(synthesizeTargets(Architectures, Platforms));
-      for (auto &ID : UUIDs)
-        File->addUUID(ID.first, ID.second);
       File->setInstallName(InstallName);
       File->setCurrentVersion(CurrentVersion);
       File->setCompatibilityVersion(CompatibilityVersion);
       File->setSwiftABIVersion(SwiftABIVersion);
       File->setObjCConstraint(ObjCConstraint);
       for (const auto &Target : File->targets())
         File->addParentUmbrella(Target, ParentUmbrella);
 
       if (Ctx->FileKind == FileType::TBD_V1) {
         File->setTwoLevelNamespace();
         File->setApplicationExtensionSafe();
       } else {
         File->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
         File->setApplicationExtensionSafe(
             !(Flags & TBDFlags::NotApplicationExtensionSafe));
-        File->setInstallAPI(Flags & TBDFlags::InstallAPI);
       }
 
       for (const auto &Section : Exports) {
         const auto Targets =
             synthesizeTargets(Section.Architectures, Platforms);
 
         for (const auto &Lib : Section.AllowableClients)
           for (const auto &Target : Targets)
template <> struct MappingTraits<const InterfaceFile *> {
   struct NormalizedTBD_V4 {
     explicit NormalizedTBD_V4(IO &IO) {}
     NormalizedTBD_V4(IO &IO, const InterfaceFile *&File) {
       auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
       assert(Ctx);
       TBDVersion = Ctx->FileKind >> 1;
       Targets.insert(Targets.begin(), File->targets().begin(),
                      File->targets().end());
-      for (const auto &IT : File->uuids())
-        UUIDs.emplace_back(IT.first, IT.second);
       InstallName = File->getInstallName();
       CurrentVersion = File->getCurrentVersion();
       CompatibilityVersion = File->getCompatibilityVersion();
       SwiftABIVersion = File->getSwiftABIVersion();
 
       Flags = TBDFlags::None;
       if (!File->isApplicationExtensionSafe())
         Flags |= TBDFlags::NotApplicationExtensionSafe;
 
       if (!File->isTwoLevelNamespace())
         Flags |= TBDFlags::FlatNamespace;
 
-      if (File->isInstallAPI())
-        Flags |= TBDFlags::InstallAPI;
-
       {
         std::map<std::string, TargetList> valueToTargetList;
         for (const auto &it : File->umbrellas())
           valueToTargetList[it.second].emplace_back(it.first);
 
         for (const auto &it : valueToTargetList) {
           UmbrellaSection CurrentSection;
           CurrentSection.Targets.insert(CurrentSection.Targets.begin(),
struct NormalizedTBD_V4 {
 
     const InterfaceFile *denormalize(IO &IO) {
       auto Ctx = reinterpret_cast<TextAPIContext *>(IO.getContext());
       assert(Ctx);
 
       auto *File = new InterfaceFile;
       File->setPath(Ctx->Path);
       File->setFileType(Ctx->FileKind);
-      for (auto &id : UUIDs)
-        File->addUUID(id.TargetID, id.Value);
       File->addTargets(Targets);
       File->setInstallName(InstallName);
       File->setCurrentVersion(CurrentVersion);
       File->setCompatibilityVersion(CompatibilityVersion);
       File->setSwiftABIVersion(SwiftABIVersion);
       for (const auto &CurrentSection : ParentUmbrellas)
         for (const auto &target : CurrentSection.Targets)
           File->addParentUmbrella(target, CurrentSection.Umbrella);
       File->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
       File->setApplicationExtensionSafe(
           !(Flags & TBDFlags::NotApplicationExtensionSafe));
-      File->setInstallAPI(Flags & TBDFlags::InstallAPI);
 
       for (const auto &CurrentSection : AllowableClients) {
         for (const auto &lib : CurrentSection.Values)
           for (const auto &Target : CurrentSection.Targets)
             File->addAllowableClient(lib, Target);
       }
 
       for (const auto &CurrentSection : ReexportedLibraries) {
void assignTargetsToLibrary(const std::vector<InterfaceFileRef> &Libraries,
         Section.emplace_back(std::move(CurrentSection));
       }
     }
   };
 
   static void mapKeysToValues(FileType FileKind, IO &IO,
                               const InterfaceFile *&File) {
     MappingNormalization<NormalizedTBD, const InterfaceFile *> Keys(IO, File);
+    std::vector<UUID> EmptyUUID;
     IO.mapRequired("archs", Keys->Architectures);
     if (FileKind != FileType::TBD_V1)
-      IO.mapOptional("uuids", Keys->UUIDs);
+      IO.mapOptional("uuids", EmptyUUID);
     IO.mapRequired("platform", Keys->Platforms);
     if (FileKind != FileType::TBD_V1)
       IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
     IO.mapRequired("install-name", Keys->InstallName);
     IO.mapOptional("current-version", Keys->CurrentVersion,
                    PackedVersion(1, 0, 0));
     IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
                    PackedVersion(1, 0, 0));
static void mapKeysToValues(FileType FileKind, IO &IO,
     IO.mapOptional("exports", Keys->Exports);
     if (FileKind != FileType::TBD_V1)
       IO.mapOptional("undefineds", Keys->Undefineds);
   }
 
   static void mapKeysToValuesV4(IO &IO, const InterfaceFile *&File) {
     MappingNormalization<NormalizedTBD_V4, const InterfaceFile *> Keys(IO,
                                                                        File);
+    std::vector<UUIDv4> EmptyUUID;
     IO.mapTag("!tapi-tbd", true);
     IO.mapRequired("tbd-version", Keys->TBDVersion);
     IO.mapRequired("targets", Keys->Targets);
-    IO.mapOptional("uuids", Keys->UUIDs);
+    IO.mapOptional("uuids", EmptyUUID);
     IO.mapOptional("flags", Keys->Flags, TBDFlags::None);
     IO.mapRequired("install-name", Keys->InstallName);
     IO.mapOptional("current-version", Keys->CurrentVersion,
                    PackedVersion(1, 0, 0));
     IO.mapOptional("compatibility-version", Keys->CompatibilityVersion,
                    PackedVersion(1, 0, 0));
     IO.mapOptional("swift-abi-version", Keys->SwiftABIVersion, SwiftVersion(0));
     IO.mapOptional("parent-umbrella", Keys->ParentUmbrellas);

llvm/lib/TextAPI/TextStubCommon.h

 };
 
 template <> struct ScalarTraits<SwiftVersion> {
   static void output(const SwiftVersion &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, SwiftVersion &);
   static QuotingType mustQuote(StringRef);
 };
 
+// UUIDs are no longer respected but kept in the YAML parser
+// to keep reading in older TBDs.
 template <> struct ScalarTraits<UUID> {
   static void output(const UUID &, void *, raw_ostream &);
   static StringRef input(StringRef, void *, UUID &);
   static QuotingType mustQuote(StringRef);
 };
 
 } // end namespace yaml.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_TEXT_STUB_COMMON_H

llvm/lib/TextAPI/TextStubCommon.cpp

if (Scalar.getAsInteger(10, Value))
     return "invalid Swift ABI version.";
 
   return StringRef();
 }
 QuotingType ScalarTraits<SwiftVersion>::mustQuote(StringRef) {
   return QuotingType::None;
 }
 
-void ScalarTraits<UUID>::output(const UUID &Value, void *, raw_ostream &OS) {
-  OS << Value.first << ": " << Value.second;
-}
+void ScalarTraits<UUID>::output(const UUID &Value, void *, raw_ostream &OS) {}
+
 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), PLATFORM_UNKNOWN};
+  Value = {};
   return {};
 }
 
 QuotingType ScalarTraits<UUID>::mustQuote(StringRef) {
   return QuotingType::Single;
 }
 
 } // end namespace yaml.
 } // end namespace llvm.

llvm/test/tools/llvm-tapi-diff/left-single-inline.test

 ; CHECK-NEXT:Inlined Reexported Frameworks/Libraries
 ; CHECK-NEXT:        Alpine.framework/Alpine
 ; CHECK-NEXT:                Current Version
 ; CHECK-NEXT:                   > 1.2.3
 ; CHECK-NEXT:                Compatibility Version
 ; CHECK-NEXT:                   > 0
 ; CHECK-NEXT:                Swift ABI Version
 ; CHECK-NEXT:                   > 5
-; CHECK-NEXT:                InstallAPI
-; CHECK-NEXT:                   > false
 ; CHECK-NEXT:                Two Level Namespace
 ; CHECK-NEXT:                   > true
 ; CHECK-NEXT:                Application Extension Safe
 ; CHECK-NEXT:                   > true
 ; CHECK-NEXT:                Allowable Clients
 ; CHECK-NEXT:                        i386-apple-macos
 ; CHECK-NEXT:                               > ClientD
 ; CHECK-NEXT:                Parent Umbrellas

llvm/test/tools/llvm-tapi-diff/mismatched-number-of-inlines.test

 ; CHECK-NEXT:Inlined Reexported Frameworks/Libraries
 ; CHECK-NEXT:    System.framework/System
 ; CHECK-NEXT:        Current Version
 ; CHECK-NEXT:                > 1.3.3
 ; CHECK-NEXT:        Compatibility Version
 ; CHECK-NEXT:                > 1.2
 ; CHECK-NEXT:        Swift ABI Version
 ; CHECK-NEXT:                > 3
-; CHECK-NEXT:        InstallAPI
-; CHECK-NEXT:                > false
 ; CHECK-NEXT:        Two Level Namespace
 ; CHECK-NEXT:                > true
 ; CHECK-NEXT:        Application Extension Safe
 ; CHECK-NEXT:                > true
 ; CHECK-NEXT:        Allowable Clients
 ; CHECK-NEXT:                i386-apple-macos
 ; CHECK-NEXT:                       > ClientA
 ; CHECK-NEXT:                x86_64-apple-ios

llvm/test/tools/llvm-tapi-diff/multiple-inlines.test

 ; CHECK-NEXT:Inlined Reexported Frameworks/Libraries
 ; CHECK-NEXT:        Alpine.framework/Alpine
 ; CHECK-NEXT:                Current Version
 ; CHECK-NEXT:                        >  1.2.3
 ; CHECK-NEXT:                Compatibility Version
 ; CHECK-NEXT:                        >  0
 ; CHECK-NEXT:                Swift ABI Version
 ; CHECK-NEXT:                        >  5
-; CHECK-NEXT:                InstallAPI
-; CHECK-NEXT:                        >  false
 ; CHECK-NEXT:                Two Level Namespace
 ; CHECK-NEXT:                        >  true
 ; CHECK-NEXT:                Application Extension Safe
 ; CHECK-NEXT:                        >  true
 ; CHECK-NEXT:                Allowable Clients
 ; CHECK-NEXT:                        i386-apple-macos
 ; CHECK-NEXT:                               > ClientD
 ; CHECK-NEXT:                Parent Umbrellas

 ; CHECK-NEXT:                                >  _symB
 ; CHECK-NEXT:        System.framework/System
 ; CHECK-NEXT:                Current Version
 ; CHECK-NEXT:                        >  1.3.3
 ; CHECK-NEXT:                Compatibility Version
 ; CHECK-NEXT:                        >  1.2
 ; CHECK-NEXT:                Swift ABI Version
 ; CHECK-NEXT:                        >  3
-; CHECK-NEXT:                InstallAPI
-; CHECK-NEXT:                        >  false
 ; CHECK-NEXT:                Two Level Namespace
 ; CHECK-NEXT:                        >  true
 ; CHECK-NEXT:                Application Extension Safe
 ; CHECK-NEXT:                        >  true
 ; CHECK-NEXT:                Allowable Clients
 ; CHECK-NEXT:                        i386-apple-macos
 ; CHECK-NEXT:                               > ClientA
 ; CHECK-NEXT:                        x86_64-apple-ios

llvm/test/tools/llvm-tapi-diff/right-single-inlines.test

 ; CHECK-NEXT:Inlined Reexported Frameworks/Libraries
 ; CHECK-NEXT:        Alpine.framework/Alpine
 ; CHECK-NEXT:                Current Version
 ; CHECK-NEXT:                        <  1.2.3
 ; CHECK-NEXT:                Compatibility Version
 ; CHECK-NEXT:                        <  0
 ; CHECK-NEXT:                Swift ABI Version
 ; CHECK-NEXT:                        <  5
-; CHECK-NEXT:                InstallAPI
-; CHECK-NEXT:                        <  false
 ; CHECK-NEXT:                Two Level Namespace
 ; CHECK-NEXT:                        <  true
 ; CHECK-NEXT:                Application Extension Safe
 ; CHECK-NEXT:                        <  true
 ; CHECK-NEXT:                Allowable Clients
 ; CHECK-NEXT:                        i386-apple-macos
 ; CHECK-NEXT:                               < ClientD
 ; CHECK-NEXT:                Parent Umbrellas

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

diffAttribute("Current Version", Output,
                 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
                     Order, Interface->getCurrentVersion()));
   diffAttribute("Compatibility Version", Output,
                 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
                     Order, Interface->getCompatibilityVersion()));
   diffAttribute("Swift ABI Version", Output,
                 DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
                     Order, Interface->getSwiftABIVersion()));
-  diffAttribute("InstallAPI", Output,
-                DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
-                    Order, Interface->isInstallAPI()));
   diffAttribute("Two Level Namespace", Output,
                 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                     Order, Interface->isTwoLevelNamespace()));
   diffAttribute("Application Extension Safe", Output,
                 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                     Order, Interface->isApplicationExtensionSafe()));
   diffAttribute("Reexported Libraries", Output,
                 Interface->reexportedLibraries(), Order);
Output.push_back(recordDifferences(
         "Compatibility Version"));
   if (IFLHS->getSwiftABIVersion() != IFRHS->getSwiftABIVersion())
     Output.push_back(
         recordDifferences(DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
                               lhs, IFLHS->getSwiftABIVersion()),
                           DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
                               rhs, IFRHS->getSwiftABIVersion()),
                           "Swift ABI Version"));
-  if (IFLHS->isInstallAPI() != IFRHS->isInstallAPI())
-    Output.push_back(recordDifferences(
-        DiffScalarVal<bool, AD_Diff_Scalar_Bool>(lhs, IFLHS->isInstallAPI()),
-        DiffScalarVal<bool, AD_Diff_Scalar_Bool>(rhs, IFRHS->isInstallAPI()),
-        "InstallAPI"));
 
   if (IFLHS->isTwoLevelNamespace() != IFRHS->isTwoLevelNamespace())
     Output.push_back(recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                                            lhs, IFLHS->isTwoLevelNamespace()),
                                        DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                                            rhs, IFRHS->isTwoLevelNamespace()),
                                        "Two Level Namespace"));
 

llvm/unittests/TextAPI/TextStubV1Tests.cpp

TEST(TBDv1, ReadFile) {
   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());
   EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_FALSE(File->isInstallAPI());
   InterfaceFileRef client("clientA", Targets);
   InterfaceFileRef reexport("/usr/lib/libfoo.dylib", Targets);
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(client, File->allowableClients().front());
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
 
   ExportedSymbolSeq Exports;
TEST(TBDv1, ReadFile2) {
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(0U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_FALSE(File->isInstallAPI());
   EXPECT_EQ(0U, File->allowableClients().size());
   EXPECT_EQ(0U, File->reexportedLibraries().size());
 }
 
 TEST(TBDv1, WriteFile) {
   static const char TBDv1File3[] =
       "---\n"
       "archs:           [ i386, x86_64 ]\n"

llvm/unittests/TextAPI/TextStubV2Tests.cpp

TEST(TBDv2, ReadFile) {
   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());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_TRUE(File->isInstallAPI());
   InterfaceFileRef client("clientA", Targets);
   InterfaceFileRef reexport("/usr/lib/libfoo.dylib", Targets);
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(client, File->allowableClients().front());
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
 
   ExportedSymbolSeq Exports;
TEST(TBDv2, ReadFile2) {
   EXPECT_EQ(Platform, *File->getPlatforms().begin());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_FALSE(File->isTwoLevelNamespace());
   EXPECT_FALSE(File->isApplicationExtensionSafe());
-  EXPECT_FALSE(File->isInstallAPI());
   EXPECT_EQ(0U, File->allowableClients().size());
   EXPECT_EQ(0U, File->reexportedLibraries().size());
 }
 
 TEST(TBDv2, WriteFile) {
   static const char TBDv2File3[] =
       "--- !tapi-tbd-v2\n"
       "archs:           [ i386, x86_64 ]\n"

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, ReadFile) {
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   TargetToAttr Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                          "00000000-0000-0000-0000-000000000000"},
                         {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());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_TRUE(File->isInstallAPI());
   InterfaceFileRef client("clientA", Targets);
   InterfaceFileRef reexport("/usr/lib/libfoo.dylib", Targets);
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(client, File->allowableClients().front());
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
 
   ExportedSymbolSeq Exports;
TEST(TBDv3, ReadFile) {
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv3Symbols)));
 }
 
 TEST(TBDv3, ReadMultipleDocuments) {
   static const char TBDv3Inlines[] =
       "--- !tapi-tbd-v3\n"
       "archs: [ armv7, arm64 ]\n"
-      "uuids: [ 'armv7: 00000000-0000-0000-0000-000000000000',\n"
-      "         'arm64: 11111111-1111-1111-1111-111111111111']\n"
       "platform: ios\n"
       "install-name: Test.dylib\n"
       "current-version: 2.3.4\n"
       "compatibility-version: 1.0\n"
       "swift-abi-version: 1.1\n"
       "parent-umbrella: Umbrella.dylib\n"
       "exports:\n"
       "  - archs: [ armv7, arm64 ]\n"
static const char TBDv3Inlines[] =
       "  - archs: [ armv7 ]\n"
       "    symbols: [ _sym5 ]\n"
       "    objc-classes: [ class3 ]\n"
       "    objc-ivars: [ class1._ivar3 ]\n"
       "    weak-def-symbols: [ _weak3 ]\n"
       "    thread-local-symbols: [ _tlv3 ]\n"
       "--- !tapi-tbd-v3\n"
       "archs: [ armv7, arm64 ]\n"
-      "uuids: [ 'armv7: 00000000-0000-0000-0000-000000000000',\n"
-      "         'arm64: 11111111-1111-1111-1111-111111111111']\n"
       "platform: ios\n"
       "install-name: TestInline.dylib\n"
       "swift-abi-version: 1.1\n"
       "exports:\n"
       "  - archs: [ armv7, arm64 ]\n"
       "    symbols: [ _sym5, _sym6 ]\n"
       "...\n";
 
   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 = PLATFORM_IOS;
   TargetList Targets;
   for (auto &&arch : Archs)
     Targets.emplace_back(Target(arch, Platform));
   EXPECT_EQ(Archs, File->getArchitectures());
   TargetToAttr Uuids = {{Target(AK_armv7, PLATFORM_UNKNOWN),
                          "00000000-0000-0000-0000-000000000000"},
                         {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());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_FALSE(File->isInstallAPI());
   InterfaceFileRef Client("clientA", Targets);
   const std::vector<InterfaceFileRef> Reexports = {
       InterfaceFileRef("/usr/lib/libfoo.dylib", Targets),
       InterfaceFileRef("TestInline.dylib", Targets)};
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(Client, File->allowableClients().front());
   EXPECT_EQ(2U, File->reexportedLibraries().size());
   EXPECT_EQ(Reexports, File->reexportedLibraries());
TEST(TBDv3, ReadMultipleDocuments) {
   EXPECT_TRUE(
       std::equal(Exports.begin(), Exports.end(), std::begin(TBDv3Symbols)));
 
   // Check Second Document
   Exports.clear();
   TBDReexportFile Document = File->documents().front();
   EXPECT_EQ(FileType::TBD_V3, Document->getFileType());
   EXPECT_EQ(Archs, Document->getArchitectures());
-  EXPECT_EQ(Uuids, Document->uuids());
   EXPECT_EQ(Platform, *Document->getPlatforms().begin());
   EXPECT_EQ(std::string("TestInline.dylib"), Document->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), Document->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), Document->getCompatibilityVersion());
   EXPECT_EQ(2U, Document->getSwiftABIVersion());
 
   for (const auto *Sym : Document->symbols()) {
     EXPECT_FALSE(Sym->isWeakReferenced());
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, PLATFORM_IOS), "Umbrella.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addAllowableClient("ClientA", Target(AK_armv7, PLATFORM_IOS));

llvm/unittests/TextAPI/TextStubV4Tests.cpp

TEST(TBDv4, ReadFile) {
   Platforms.insert(getPlatformFromName("macos"));
   Platforms.insert(getPlatformFromName("ios"));
   auto Archs = AK_i386 | AK_x86_64;
   TargetList Targets = {
       Target(AK_i386, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_IOS),
   };
-  TargetToAttr 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())
     EXPECT_EQ(Platforms.count(Platform), 1U);
   EXPECT_EQ(std::string("Umbrella.framework/Umbrella"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 2, 3), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 2, 0), File->getCompatibilityVersion());
   EXPECT_EQ(5U, File->getSwiftABIVersion());
   EXPECT_FALSE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_TRUE(File->isInstallAPI());
   InterfaceFileRef client("ClientA", Targets);
   InterfaceFileRef reexport("/System/Library/Frameworks/A.framework/A",
                             {Targets[0]});
   EXPECT_EQ(1U, File->allowableClients().size());
   EXPECT_EQ(client, File->allowableClients().front());
   EXPECT_EQ(1U, File->reexportedLibraries().size());
   EXPECT_EQ(reexport, File->reexportedLibraries().front());
 

 }
 
 TEST(TBDv4, ReadMultipleDocuments) {
   static const char TBDv4Inlines[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [ i386-macos, i386-maccatalyst, x86_64-macos, "
       "x86_64-maccatalyst ]\n"
-      "uuids:\n"
-      "  - target: i386-macos\n"
-      "    value: 00000000-0000-0000-0000-000000000000\n"
-      "  - target: i386-maccatalyst\n"
-      "    value: 00000000-0000-0000-0000-000000000002\n"
-      "  - target: x86_64-macos\n"
-      "    value: 11111111-1111-1111-1111-111111111111\n"
-      "  - target: x86_64-maccatalyst\n"
-      "    value: 11111111-1111-1111-1111-111111111112\n"
       "install-name: /System/Library/Frameworks/Umbrella.framework/Umbrella\n"
       "parent-umbrella:\n"
       "  - targets: [ i386-macos, x86_64-macos ]\n"
       "    umbrella: System\n"
       "reexported-libraries:\n"
       "  - targets: [ i386-macos, x86_64-macos ]\n"
       "    libraries: [ /System/Library/Frameworks/A.framework/A ]\n"
       "--- !tapi-tbd\n"
TEST(TBDv4, ReadMultipleDocuments) {
   };
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv4Inlines, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   TBDFile File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V4, File->getFileType());
   EXPECT_EQ(Archs, File->getArchitectures());
-  EXPECT_EQ(Uuids, File->uuids());
   EXPECT_EQ(Platforms, File->getPlatforms());
   EXPECT_EQ(
       std::string("/System/Library/Frameworks/Umbrella.framework/Umbrella"),
       File->getInstallName());
   EXPECT_TRUE(File->isTwoLevelNamespace());
   EXPECT_TRUE(File->isApplicationExtensionSafe());
-  EXPECT_FALSE(File->isInstallAPI());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   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();
   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();
   EXPECT_EQ(FileType::TBD_V4, Document->getFileType());
   EXPECT_EQ(Archs, Document->getArchitectures());
-  EXPECT_EQ(Uuids, Document->uuids());
   EXPECT_EQ(1U, Document->getPlatforms().size());
   EXPECT_EQ(Platform, *(Document->getPlatforms().begin()));
   EXPECT_EQ(std::string("/System/Library/Frameworks/A.framework/A"),
             Document->getInstallName());
   EXPECT_EQ(PackedVersion(1, 2, 3), Document->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 2, 0), Document->getCompatibilityVersion());
   EXPECT_EQ(5U, Document->getSwiftABIVersion());
   EXPECT_FALSE(Document->isTwoLevelNamespace());
   EXPECT_TRUE(Document->isApplicationExtensionSafe());
-  EXPECT_FALSE(Document->isInstallAPI());
 
   ExportedSymbolSeq Exports;
   ExportedSymbolSeq Reexports, Undefineds;
   for (const auto *Sym : Document->symbols()) {
     ExportedSymbol Temp =
         ExportedSymbol{Sym->getKind(), std::string(Sym->getName()),
                        Sym->isWeakDefined(), Sym->isThreadLocalValue()};
     EXPECT_FALSE(Sym->isWeakReferenced());
EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
                          std::begin(ExpectedUndefinedSymbols)));
 }
 
 TEST(TBDv4, WriteFile) {
   static const char TBDv4File[] =
       "--- !tapi-tbd\n"
       "tbd-version:     4\n"
       "targets:         [ i386-macos, x86_64-ios-simulator ]\n"
-      "uuids:\n"
-      "  - target:          i386-macos\n"
-      "    value:           00000000-0000-0000-0000-000000000000\n"
-      "  - target:          x86_64-ios-simulator\n"
-      "    value:           11111111-1111-1111-1111-111111111111\n"
-      "flags:           [ installapi ]\n"
       "install-name:    'Umbrella.framework/Umbrella'\n"
       "current-version: 1.2.3\n"
       "compatibility-version: 0\n"
       "swift-abi-version: 5\n"
       "parent-umbrella:\n"
       "  - targets:         [ i386-macos, x86_64-ios-simulator ]\n"
       "    umbrella:        System\n"
       "allowable-clients:\n"
       "  - targets:         [ i386-macos ]\n"
       "    clients:         [ ClientA ]\n"
       "exports:\n"
       "  - targets:         [ i386-macos ]\n"
       "    symbols:         [ _symA ]\n"
       "    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, PLATFORM_MACOS),
       Target(AK_x86_64, PLATFORM_IOSSIMULATOR),
   };
-  TargetToAttr 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);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
-  File.setInstallAPI(true);
   File.setApplicationExtensionSafe(true);
   File.setSwiftABIVersion(5);
   File.addAllowableClient("ClientA", Targets[0]);
   File.addParentUmbrella(Targets[0], "System");
   File.addParentUmbrella(Targets[1], "System");
   File.addSymbol(SymbolKind::GlobalSymbol, "_symA", {Targets[0]});
   File.addSymbol(SymbolKind::GlobalSymbol, "_symB", {Targets[1]});
   File.addSymbol(SymbolKind::GlobalSymbol, "_symC", {Targets[0]},
                  SymbolFlags::WeakDefined);
   File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", {Targets[0]});
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   Error Result = TextAPIWriter::writeToStream(OS, File);
   EXPECT_FALSE(Result);
   EXPECT_STREQ(TBDv4File, Buffer.c_str());
 }
 
 TEST(TBDv4, WriteMultipleDocuments) {
   static const char TBDv4Inlines[] =
       "--- !tapi-tbd\n"
       "tbd-version:     4\n"
       "targets:         [ i386-maccatalyst, x86_64-maccatalyst ]\n"
-      "uuids:\n"
-      "  - target:          i386-maccatalyst\n"
-      "    value:           00000000-0000-0000-0000-000000000002\n"
-      "  - target:          x86_64-maccatalyst\n"
-      "    value:           11111111-1111-1111-1111-111111111112\n"
       "install-name:    "
       "'/System/Library/Frameworks/Umbrella.framework/Umbrella'\n"
       "reexported-libraries:\n"
       "  - targets:         [ i386-maccatalyst, x86_64-maccatalyst ]\n"
       "    libraries:       [ '/System/Library/Frameworks/A.framework/A' ]\n"
       "--- !tapi-tbd\n"
       "tbd-version:     4\n"
       "targets:         [ i386-maccatalyst, x86_64-maccatalyst ]\n"
-      "uuids:\n"
-      "  - target:          i386-maccatalyst\n"
-      "    value:           00000000-0000-0000-0000-000000000000\n"
-      "  - target:          x86_64-maccatalyst\n"
-      "    value:           11111111-1111-1111-1111-111111111111\n"
       "install-name:    '/System/Library/Frameworks/A.framework/A'\n"
       "exports:\n"
       "  - targets:         [ i386-maccatalyst ]\n"
       "    weak-symbols:    [ _symC ]\n"
       "  - 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;
   PlatformType Platform = PLATFORM_MACCATALYST;
   TargetList Targets = {
       Target(AK_i386, Platform),
       Target(AK_x86_64, Platform),
   };
   TargetToAttr 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);
   File.addTargets(Targets);
-  File.addUUID(Uuids[0].first, Uuids[0].second);
-  File.addUUID(Uuids[1].first, Uuids[1].second);
   File.setCompatibilityVersion(PackedVersion(1, 0, 0));
   File.setCurrentVersion(PackedVersion(1, 0, 0));
   File.setTwoLevelNamespace();
   File.setApplicationExtensionSafe(true);
   File.addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
                             Targets[0]);
   File.addReexportedLibrary("/System/Library/Frameworks/A.framework/A",
                             Targets[1]);
 
   // Write Second Document
   Uuids = {{Targets[0], "00000000-0000-0000-0000-000000000000"},
            {Targets[1], "11111111-1111-1111-1111-111111111111"}};
   InterfaceFile Document;
   Document.setInstallName("/System/Library/Frameworks/A.framework/A");
   Document.setFileType(FileType::TBD_V4);
   Document.addTargets(Targets);
-  Document.addUUID(Uuids[0].first, Uuids[0].second);
-  Document.addUUID(Uuids[1].first, Uuids[1].second);
   Document.setCompatibilityVersion(PackedVersion(1, 0, 0));
   Document.setCurrentVersion(PackedVersion(1, 0, 0));
   Document.setTwoLevelNamespace();
   Document.setApplicationExtensionSafe(true);
   Document.addSymbol(SymbolKind::GlobalSymbol, "_symA", Targets);
   Document.addSymbol(SymbolKind::GlobalSymbol, "_symAB", {Targets[1]});
   Document.addSymbol(SymbolKind::GlobalSymbol, "_symC", {Targets[0]},
                      SymbolFlags::WeakDefined);

 }
 
 TEST(TBDv4, InterfaceEquality) {
   static const char TBDv4File[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets:  [ i386-macos, x86_64-macos, x86_64-ios, i386-maccatalyst, "
       "x86_64-maccatalyst ]\n"
-      "uuids:\n"
-      "  - target: i386-macos\n"
-      "    value: 00000000-0000-0000-0000-000000000000\n"
-      "  - target: x86_64-macos\n"
-      "    value: 11111111-1111-1111-1111-111111111111\n"
-      "  - target: x86_64-ios\n"
-      "    value: 11111111-1111-1111-1111-111111111111\n"
-      "  - target: i386-maccatalyst\n"
-      "    value: 00000000-0000-0000-0000-000000000000\n"
-      "  - target: x86_64-maccatalyst\n"
-      "    value: 11111111-1111-1111-1111-111111111111\n"
-      "flags: [ flat_namespace, installapi ]\n"
       "install-name: Umbrella.framework/Umbrella\n"
       "current-version: 1.2.3\n"
       "compatibility-version: 1.2\n"
       "swift-abi-version: 5\n"
       "parent-umbrella:\n"
       "  - targets: [ i386-macos, x86_64-macos, x86_64-ios ]\n"
       "    umbrella: System\n"
       "allowable-clients:\n"
TEST(TBDv4, InterfaceEquality) {
   EXPECT_TRUE(FileA == FileB);
 }
 
 TEST(TBDv4, InterfaceDiffVersionsEquality) {
   static const char TBDv4File[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets:  [ i386-macos, x86_64-macos ]\n"
-      "uuids:\n"
-      "  - target: i386-macos\n"
-      "    value: 00000000-0000-0000-0000-000000000000\n"
-      "  - target: x86_64-macos\n"
-      "    value: 11111111-1111-1111-1111-111111111111\n"
-      "flags: [ installapi ]\n"
       "install-name: Umbrella.framework/Umbrella\n"
       "current-version: 1.2.3\n"
       "compatibility-version: 1.0\n"
       "swift-abi-version: 5\n"
       "parent-umbrella:\n"
       "  - targets: [ i386-macos, x86_64-macos ]\n"
       "    umbrella: System\n"
       "allowable-clients:\n"
static const char TBDv4File[] =
       "    objc-ivars: []\n"
       "    weak-symbols: []\n"
       "    thread-local-symbols: []\n"
       "...\n";
 
   static const char TBDv3File[] =
       "--- !tapi-tbd-v3\n"
       "archs: [ i386, x86_64 ]\n"
-      "uuids: [ 'i386: 00000000-0000-0000-0000-000000000000',\n"
-      "         'x86_64: 22222222-2222-2222-2222-222222222222']\n"
       "platform: macosx\n"
-      "flags: [ installapi ]\n"
       "install-name: Umbrella.framework/Umbrella\n"
       "current-version: 1.2.3\n"
       "compatibility-version: 1.0\n"
       "swift-abi-version: 5\n"
       "parent-umbrella: System\n"
       "exports:\n"
       "  - archs: [ i386, x86_64 ]\n"
       "    allowable-clients: [ ClientA ]\n"
TEST(TBDv4, InterfaceDiffVersionsEquality) {
   Expected<TBDFile> ResultA =
       TextAPIReader::get(MemoryBufferRef(TBDv4File, "TestA.tbd"));
   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_NE(FileA.uuids(), FileB.uuids());
   EXPECT_TRUE(FileA == FileB);
 }
 
 TEST(TBDv4, InterfaceInequality) {
   static const char TBDv4File[] = "--- !tapi-tbd\n"
                                   "tbd-version: 4\n"
                                   "targets:  [ i386-macos, x86_64-macos ]\n"
                                   "install-name: Umbrella.framework/Umbrella\n"
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, PLATFORM_MACOS), "System.dylib");
   }));
   EXPECT_TRUE(checkEqualityOnTransform(FileA, FileB, [](InterfaceFile *File) {
     File->addAllowableClient("ClientA", Target(AK_i386, PLATFORM_MACOS));