[llvm][TextAPI] adding inlining reexported libraries support

[cishida]

Summary

[llvm][TextAPI] adding inlining reexported libraries support

• this patch adds reader/writer support for MachO tbd files.

The usecase is to represent reexported libraries in top level library
that won't need to exist for linker indirection because all of the
needed content will be inlined in the same document.

[ributzka]

Does nm print now all symbols - including the inlined ones? That would be an unexpected change, because we don't do the same for MachOs that have re-exported frameworks. I think this feature should be guarded by an option.

[cishida]

Updating this patch to just create inlining framework support, and I will attach lib/Object & nm support in a seperate patch

[ributzka]

LGTM

[jhenderson]

llvm/include/llvm/TextAPI/MachO/InterfaceFile.h

336–338

Nit here and below in comments - missing trailing full stops.

350

Nit: too many blank lines

llvm/unittests/TextAPI/TextStubV4Tests.cpp

477

There's a lot of usage of auto in this and the other files, and I'm pretty sure this is stretching LLVM's coding standard on the topic - the type isn't obvious. See https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable.

[cishida]

the lint corrections will be/have been made in the revision that lands.

llvm/unittests/TextAPI/TextStubV4Tests.cpp

477

got it! I will update these files to update these usages in a separate patch to conform to the standard.

llvm/include/llvm/TextAPI/MachO/InterfaceFile.h

public:
 
   /// 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
+  /// umbrellas.
   const std::vector<std::pair<Target, std::string>> &umbrellas() const {
     return ParentUmbrellas;
   }
 
   /// Add an allowable client.
   ///
   /// Mach-O Dynamic libraries have the concept of allowable clients that are
   /// checked during static link time. The name of the application or library
public:
 
   /// 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) {
+    Documents.emplace_back(std::move(Document));
+  }
+
+  /// Get the list of inlined libraries.
+  ///
+  /// \return Returns a list of the inlined frameworks.
+  const std::vector<std::shared_ptr<InterfaceFile>> &documents() const {
+    return Documents;
+  }
+
   /// Add a symbol to the symbols list or extend an existing one.
   void addSymbol(SymbolKind Kind, StringRef Name, const TargetList &Targets,
                  SymbolFlags Flags = SymbolFlags::None);
 
   using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
   struct const_symbol_iterator
       : public iterator_adaptor_base<
             const_symbol_iterator, SymbolMapType::const_iterator,
             std::forward_iterator_tag, const Symbol *, ptrdiff_t,
private:
   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;
   SymbolMapType Symbols;
 };
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_MACHO_INTERFACE_FILE_H

llvm/lib/TextAPI/MachO/TextStub.cpp

TextAPIReader::get(MemoryBufferRef InputBuffer) {
   std::vector<const InterfaceFile *> Files;
   YAMLIn >> Files;
 
   // YAMLIn dynamically allocates for Interface file and in case of error,
   // memory leak will occur unless wrapped around unique_ptr
   auto File = std::unique_ptr<InterfaceFile>(
       const_cast<InterfaceFile *>(Files.front()));
 
+  for (auto Iter = std::next(Files.begin()); Iter != Files.end(); ++Iter)
+    File->addDocument(
+        std::shared_ptr<InterfaceFile>(const_cast<InterfaceFile *>(*Iter)));
+
   if (YAMLIn.error())
     return make_error<StringError>(Ctx.ErrorMessage, YAMLIn.error());
 
   return std::move(File);
 }
 
 Error TextAPIWriter::writeToStream(raw_ostream &OS, const InterfaceFile &File) {
   TextAPIContext Ctx;
   Ctx.Path = std::string(File.getPath());
   Ctx.FileKind = File.getFileType();
   llvm::yaml::Output YAMLOut(OS, &Ctx, /*WrapColumn=*/80);
 
   std::vector<const InterfaceFile *> Files;
   Files.emplace_back(&File);
 
+  for (auto Document : File.documents())
+    Files.emplace_back(Document.get());
+
   // Stream out yaml.
   YAMLOut << Files;
 
   return Error::success();
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/unittests/TextAPI/TextStubV3Tests.cpp

TEST(TBDv3, ReadFile) {
   }
   llvm::sort(Exports.begin(), Exports.end());
 
   EXPECT_EQ(sizeof(TBDv3Symbols) / sizeof(ExportedSymbol), Exports.size());
   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"
+      "    allowable-clients: [ clientA ]\n"
+      "    re-exports: [ /usr/lib/libfoo.dylib,\n"
+      "                  TestInline.dylib ]\n"
+      "    symbols: [ _sym1, _sym2, _sym3, _sym4, $ld$hide$os9.0$_sym1 ]\n"
+      "    objc-classes: [ class1, class2 ]\n"
+      "    objc-eh-types: [ class1 ]\n"
+      "    objc-ivars: [ class1._ivar1, class1._ivar2 ]\n"
+      "    weak-def-symbols: [ _weak1, _weak2 ]\n"
+      "    thread-local-symbols: [ _tlv1, _tlv3 ]\n"
+      "  - 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";
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(TBDv3Inlines, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto 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;
+  TargetList Targets;
+  for (auto &&arch : Archs)
+    Targets.emplace_back(Target(arch, Platform));
+  EXPECT_EQ(Archs, File->getArchitectures());
+  UUIDs Uuids = {{Target(AK_armv7, PlatformKind::unknown),
+                  "00000000-0000-0000-0000-000000000000"},
+                 {Target(AK_arm64, PlatformKind::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());
+
+  ExportedSymbolSeq Exports;
+  for (const auto *Sym : File->symbols()) {
+    EXPECT_FALSE(Sym->isWeakReferenced());
+    EXPECT_FALSE(Sym->isUndefined());
+    Exports.emplace_back(ExportedSymbol{Sym->getKind(), Sym->getName().str(),
+                                        Sym->isWeakDefined(),
+                                        Sym->isThreadLocalValue()});
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+
+  EXPECT_EQ(sizeof(TBDv3Symbols) / sizeof(ExportedSymbol), Exports.size());
+  EXPECT_TRUE(
+      std::equal(Exports.begin(), Exports.end(), std::begin(TBDv3Symbols)));
+
+  // Check Second Document
+  Exports.clear();
+  auto 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_FALSE(Sym->isUndefined());
+    Exports.emplace_back(ExportedSymbol{Sym->getKind(), Sym->getName().str(),
+                                        Sym->isWeakDefined(),
+                                        Sym->isThreadLocalValue()});
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+
+  ExportedSymbolSeq DocumentSymbols{
+      {SymbolKind::GlobalSymbol, "_sym5", false, false},
+      {SymbolKind::GlobalSymbol, "_sym6", false, false},
+  };
+
+  EXPECT_EQ(DocumentSymbols.size(), Exports.size());
+  EXPECT_TRUE(
+      std::equal(Exports.begin(), Exports.end(), DocumentSymbols.begin()));
+}
+
 TEST(TBDv3, WriteFile) {
   static const char TBDv3File3[] =
       "--- !tapi-tbd-v3\n"
       "archs:           [ i386, x86_64 ]\n"
       "platform:        macosx\n"
       "install-name:    '/usr/lib/libfoo.dylib'\n"
       "current-version: 1.2.3\n"
       "compatibility-version: 0\n"
TEST(TBDv3, WriteFile) {
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   auto Result = TextAPIWriter::writeToStream(OS, File);
   EXPECT_FALSE(Result);
   EXPECT_STREQ(TBDv3File3, Buffer.c_str());
 }
 
+TEST(TBDv3, WriteMultipleDocuments) {
+  static const char TBDv3Inlines[] =
+      "--- !tapi-tbd-v3\n"
+      "archs:           [ i386, x86_64 ]\n"
+      "platform:        zippered\n"
+      "install-name:    '/usr/lib/libfoo.dylib'\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 0\n"
+      "swift-abi-version: 5\n"
+      "exports:\n"
+      "  - archs:           [ x86_64 ]\n"
+      "    allowable-clients: [ clientA ]\n"
+      "    re-exports:      [ '/usr/lib/libbar.dylib' ]\n"
+      "  - archs:           [ i386, x86_64 ]\n"
+      "    symbols:         [ _sym1 ]\n"
+      "    objc-classes:    [ Class1 ]\n"
+      "    objc-eh-types:   [ Class1 ]\n"
+      "    objc-ivars:      [ Class1._ivar1 ]\n"
+      "    weak-def-symbols: [ _sym2 ]\n"
+      "    thread-local-symbols: [ _symA ]\n"
+      "--- !tapi-tbd-v3\n"
+      "archs:           [ i386 ]\n"
+      "platform:        macosx\n"
+      "install-name:    '/usr/lib/libbar.dylib'\n"
+      "current-version: 0\n"
+      "compatibility-version: 0\n"
+      "swift-abi-version: 5\n"
+      "objc-constraint: none\n"
+      "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));
+  }
+  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)};
+  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);
+  Document.addSymbol(SymbolKind::GlobalSymbol, "_sym4", Targets);
+  File.addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
+  
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto Result = TextAPIWriter::writeToStream(OS, File);
+  EXPECT_FALSE(Result);
+  EXPECT_STREQ(TBDv3Inlines, Buffer.c_str());
+}
+
 TEST(TBDv3, Platform_macOS) {
   static const char TBDv3PlatformMacOS[] = "--- !tapi-tbd-v3\n"
                                            "archs: [ x86_64 ]\n"
                                            "platform: macosx\n"
                                            "install-name: Test.dylib\n"
                                            "...\n";
 
   auto Result =

llvm/unittests/TextAPI/TextStubV4Tests.cpp

 #include "llvm/TextAPI/MachO/TextAPIWriter.h"
 #include "gtest/gtest.h"
 #include <string>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::MachO;
 
-static ExportedSymbol TBDv4ExportedSymbols[] = {
-    {SymbolKind::GlobalSymbol, "_symA", false, false},
-    {SymbolKind::GlobalSymbol, "_symAB", false, false},
-    {SymbolKind::GlobalSymbol, "_symB", false, false},
-};
-
-static ExportedSymbol TBDv4ReexportedSymbols[] = {
-    {SymbolKind::GlobalSymbol, "_symC", false, false},
-};
-
-static ExportedSymbol TBDv4UndefinedSymbols[] = {
-    {SymbolKind::GlobalSymbol, "_symD", false, false},
-};
 
 namespace TBDv4 {
 
 TEST(TBDv4, ReadFile) {
   static const char TBDv4File[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets:  [ i386-macos, x86_64-macos, x86_64-ios ]\n"
for (const auto *Sym : File->symbols()) {
     else
       Sym->isReexported() ? Reexports.emplace_back(std::move(temp))
                           : Exports.emplace_back(std::move(temp));
   }
   llvm::sort(Exports.begin(), Exports.end());
   llvm::sort(Reexports.begin(), Reexports.end());
   llvm::sort(Undefineds.begin(), Undefineds.end());
 
-  EXPECT_EQ(sizeof(TBDv4ExportedSymbols) / sizeof(ExportedSymbol),
+  static ExportedSymbol ExpectedExportedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symA", false, false},
+      {SymbolKind::GlobalSymbol, "_symAB", false, false},
+      {SymbolKind::GlobalSymbol, "_symB", false, false},
+  };
+
+  static ExportedSymbol ExpectedReexportedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symC", false, false},
+  };
+
+  static ExportedSymbol ExpectedUndefinedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symD", false, false},
+  };
+
+  EXPECT_EQ(sizeof(ExpectedExportedSymbols) / sizeof(ExportedSymbol),
+            Exports.size());
+  EXPECT_EQ(sizeof(ExpectedReexportedSymbols) / sizeof(ExportedSymbol),
+            Reexports.size());
+  EXPECT_EQ(sizeof(ExpectedUndefinedSymbols) / sizeof(ExportedSymbol),
+            Undefineds.size());
+  EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
+                         std::begin(ExpectedExportedSymbols)));
+  EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),
+                         std::begin(ExpectedReexportedSymbols)));
+  EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
+                         std::begin(ExpectedUndefinedSymbols)));
+}
+
+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"
+      "tbd-version: 4\n"
+      "targets:  [ i386-macos, x86_64-macos ]\n"
+      "uuids:\n"
+      "  - target: i386-macos\n"
+      "    value: 20000000-0000-0000-0000-000000000000\n"
+      "  - target: x86_64-macos\n"
+      "    value: 21111111-1111-1111-1111-111111111111\n"
+      "flags: [ flat_namespace ]\n"
+      "install-name: /System/Library/Frameworks/A.framework/A\n"
+      "current-version: 1.2.3\n"
+      "compatibility-version: 1.2\n"
+      "swift-abi-version: 5\n"
+      "exports:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [ _symA ]\n"
+      "    objc-classes: []\n"
+      "    objc-eh-types: []\n"
+      "    objc-ivars: []\n"
+      "    weak-symbols: []\n"
+      "    thread-local-symbols: []\n"
+      "  - targets: [ x86_64-macos ]\n"
+      "    symbols: [_symAB]\n"
+      "reexports:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [_symC]\n"
+      "    objc-classes: []\n"
+      "    objc-eh-types: []\n"
+      "    objc-ivars: []\n"
+      "    weak-symbols: []\n"
+      "    thread-local-symbols: []\n"
+      "undefineds:\n"
+      "  - targets: [ i386-macos ]\n"
+      "    symbols: [ _symD ]\n"
+      "    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);
+  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"},
+      {Targets[2], "11111111-1111-1111-1111-111111111111"},
+      {Targets[3], "11111111-1111-1111-1111-111111111112"},
+  };
+
+  auto Result = TextAPIReader::get(MemoryBufferRef(TBDv4Inlines, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  auto 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());
+  ExportedSymbolSeq Exports;
+  for (const auto *Sym : File->symbols()) {
+    EXPECT_FALSE(Sym->isWeakReferenced());
+    EXPECT_FALSE(Sym->isUndefined());
+    Exports.emplace_back(ExportedSymbol{Sym->getKind(), Sym->getName().str(),
+                                        Sym->isWeakDefined(),
+                                        Sym->isThreadLocalValue()});
+  }
+  EXPECT_EQ(0U, Exports.size());
+
+  // Check Inlined Document
+  Exports.clear();
+  Targets.clear();
+  Uuids.clear();
+  PlatformKind Platform = PlatformKind::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"},
+  };
+
+  auto 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 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());
+    if (Sym->isUndefined())
+      Undefineds.emplace_back(std::move(Temp));
+    else
+      Sym->isReexported() ? Reexports.emplace_back(std::move(Temp))
+                          : Exports.emplace_back(std::move(Temp));
+  }
+  llvm::sort(Exports.begin(), Exports.end());
+  llvm::sort(Reexports.begin(), Reexports.end());
+  llvm::sort(Undefineds.begin(), Undefineds.end());
+
+  static ExportedSymbol ExpectedExportedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symA", false, false},
+      {SymbolKind::GlobalSymbol, "_symAB", false, false},
+  };
+
+  static ExportedSymbol ExpectedReexportedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symC", false, false},
+  };
+
+  static ExportedSymbol ExpectedUndefinedSymbols[] = {
+      {SymbolKind::GlobalSymbol, "_symD", false, false},
+  };
+
+  EXPECT_EQ(sizeof(ExpectedExportedSymbols) / sizeof(ExportedSymbol),
             Exports.size());
-  EXPECT_EQ(sizeof(TBDv4ReexportedSymbols) / sizeof(ExportedSymbol),
+  EXPECT_EQ(sizeof(ExpectedReexportedSymbols) / sizeof(ExportedSymbol),
             Reexports.size());
-  EXPECT_EQ(sizeof(TBDv4UndefinedSymbols) / sizeof(ExportedSymbol),
+  EXPECT_EQ(sizeof(ExpectedUndefinedSymbols) / sizeof(ExportedSymbol),
             Undefineds.size());
   EXPECT_TRUE(std::equal(Exports.begin(), Exports.end(),
-                         std::begin(TBDv4ExportedSymbols)));
+                         std::begin(ExpectedExportedSymbols)));
   EXPECT_TRUE(std::equal(Reexports.begin(), Reexports.end(),
-                         std::begin(TBDv4ReexportedSymbols)));
+                         std::begin(ExpectedReexportedSymbols)));
   EXPECT_TRUE(std::equal(Undefineds.begin(), Undefineds.end(),
-                         std::begin(TBDv4UndefinedSymbols)));
+                         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"
TEST(TBDv4, WriteFile) {
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   auto 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;
+  PlatformKind Platform = PlatformKind::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);
+  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);
+  Document.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Targets);
+  File.addDocument(std::make_shared<InterfaceFile>(std::move(Document)));
+
+  SmallString<4096> Buffer;
+  raw_svector_ostream OS(Buffer);
+  auto Result = TextAPIWriter::writeToStream(OS, File);
+  EXPECT_FALSE(Result);
+  EXPECT_STREQ(TBDv4Inlines, Buffer.c_str());
+}
+
 TEST(TBDv4, MultipleTargets) {
   static const char TBDv4MultipleTargets[] =
       "--- !tapi-tbd\n"
       "tbd-version: 4\n"
       "targets: [ i386-maccatalyst, x86_64-tvos, arm64-ios ]\n"
       "install-name: Test.dylib\n"
       "...\n";