[TextAPI] Update reader to be supported by lib/Object

[cishida]

Summary

To be able to use the TextAPI/Reader for tbd file consumption (by libObject)
it gets passed a MemoryBufferRef which isn't castable to MemoryBuffer.
Updated the tests to expect that input as well.

[steven_wu]

LGTM

llvm/include/llvm/TextAPI/MachO/TextAPIReader.h

25 ↗

(On Diff #214853)

What happened to this function? Is this declared and never implemented?

[cishida]

I currently don't have commit access, so would anyone mind pushing this up to master?

llvm/include/llvm/TextAPI/MachO/TextAPIReader.h

25 ↗

(On Diff #214853)

yep, never created an error because it was never called by anything

[ributzka]

llvm/lib/TextAPI/MachO/TextStub.cpp

638 ↗

(On Diff #214853)

Why did this move? Won't that leak the memory in the error case?

[cishida]

[TextAPI] prevent memory leak for Interface File

[cishida]

llvm/lib/TextAPI/MachO/TextStub.cpp

638 ↗

(On Diff #214853)

resolved offline

llvm/trunk/include/llvm/TextAPI/MachO/TextAPIReader.h

 namespace llvm {
 namespace MachO {
 
 class InterfaceFile;
 
 class TextAPIReader {
 public:
   static Expected<std::unique_ptr<InterfaceFile>>
-  get(std::unique_ptr<MemoryBuffer> InputBuffer);
-
-  static Expected<std::unique_ptr<InterfaceFile>>
-  getUnmanaged(llvm::MemoryBuffer *InputBuffer);
+  get(MemoryBufferRef InputBuffer);
 
   TextAPIReader() = delete;
 };
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_MACHO_READER_H

llvm/trunk/lib/TextAPI/MachO/TextStub.cpp

SMDiagnostic NewDiag(*Diag.getSourceMgr(), Diag.getLoc(), File->Path,
                        Diag.getMessage(), Diag.getLineContents(),
                        Diag.getRanges(), Diag.getFixIts());
 
   NewDiag.print(nullptr, S);
   File->ErrorMessage = ("malformed file\n" + Message).str();
 }
 
 Expected<std::unique_ptr<InterfaceFile>>
-TextAPIReader::get(std::unique_ptr<MemoryBuffer> InputBuffer) {
+TextAPIReader::get(MemoryBufferRef InputBuffer) {
   TextAPIContext Ctx;
-  Ctx.Path = InputBuffer->getBufferIdentifier();
-  yaml::Input YAMLIn(InputBuffer->getBuffer(), &Ctx, DiagHandler, &Ctx);
+  Ctx.Path = InputBuffer.getBufferIdentifier();
+  yaml::Input YAMLIn(InputBuffer.getBuffer(), &Ctx, DiagHandler, &Ctx);
 
   // Fill vector with interface file objects created by parsing the YAML file.
   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()));
 
   if (YAMLIn.error())
     return make_error<StringError>(Ctx.ErrorMessage, YAMLIn.error());
 
   return std::move(File);
 }

llvm/trunk/unittests/TextAPI/TextStubV1Tests.cpp

static const char tbd_v1_file1[] =
       "  - archs: [ armv7, armv7s, armv7k ]\n"
       "    symbols: [ _sym5 ]\n"
       "    objc-classes: [ _class3 ]\n"
       "    objc-ivars: [ _class1._ivar3 ]\n"
       "    weak-def-symbols: [ _weak3 ]\n"
       "    thread-local-symbols: [ _tlv3 ]\n"
       "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_file1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());

 
 TEST(TBDv1, ReadFile2) {
   static const char tbd_v1_file2[] = "--- !tapi-tbd-v1\n"
                                      "archs: [ armv7, armv7s, armv7k, arm64 ]\n"
                                      "platform: ios\n"
                                      "install-name: Test.dylib\n"
                                      "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file2, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_file2, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());

 
 TEST(TBDv1, Platform_macOS) {
   static const char tbd_v1_platform_macos[] = "---\n"
                                               "archs: [ x86_64 ]\n"
                                               "platform: macosx\n"
                                               "install-name: Test.dylib\n"
                                               "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_macos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_macos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(PlatformKind::macOS, File->getPlatform());
 }
 
 TEST(TBDv1, Platform_iOS) {
   static const char tbd_v1_platform_ios[] = "---\n"
                                             "archs: [ arm64 ]\n"
                                             "platform: ios\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_ios, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_ios, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
 }
 
 TEST(TBDv1, Platform_watchOS) {
   static const char tbd_v1_platform_watchos[] = "---\n"
                                                 "archs: [ armv7k ]\n"
                                                 "platform: watchos\n"
                                                 "install-name: Test.dylib\n"
                                                 "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_watchos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_watchos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(PlatformKind::watchOS, File->getPlatform());
 }
 
 TEST(TBDv1, Platform_tvOS) {
   static const char tbd_v1_platform_tvos[] = "---\n"
                                              "archs: [ arm64 ]\n"
                                              "platform: tvos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_tvos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_tvos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(PlatformKind::tvOS, File->getPlatform());
 }
 
 TEST(TBDv1, Platform_bridgeOS) {
   static const char tbd_v1_platform_bridgeos[] = "---\n"
                                                  "archs: [ armv7k ]\n"
                                                  "platform: bridgeos\n"
                                                  "install-name: Test.dylib\n"
                                                  "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v1_platform_bridgeos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_bridgeos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(PlatformKind::bridgeOS, File->getPlatform());
 }
 
 TEST(TBDv1, Swift_1_0) {
   static const char tbd_v1_swift_1_0[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 1.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(1U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, Swift_1_1) {
   static const char tbd_v1_swift_1_1[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 1.1\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, Swift_2_0) {
   static const char tbd_v1_swift_2_0[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 2.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_2_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_2_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(3U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, Swift_3_0) {
   static const char tbd_v1_swift_3_0[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 3.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_3_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_3_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(4U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, Swift_4_0) {
   static const char tbd_v1_swift_4_0[] = "---\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 4.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_4_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_4_0, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
             "version.\nswift-version: 4.0\n               ^~~\n",
             errorMessage);
 }
 
 TEST(TBDv1, Swift_5) {
   static const char tbd_v1_swift_5[] = "---\n"
                                        "archs: [ arm64 ]\n"
                                        "platform: ios\n"
                                        "install-name: Test.dylib\n"
                                        "swift-version: 5\n"
                                        "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_5, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_5, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(5U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, Swift_99) {
   static const char tbd_v1_swift_99[] = "---\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "swift-version: 99\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_99, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_99, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
   EXPECT_EQ(99U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv1, UnknownArchitecture) {
   static const char tbd_v1_file_unknown_architecture[] =
       "---\n"
       "archs: [ foo ]\n"
       "platform: macosx\n"
       "install-name: Test.dylib\n"
       "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v1_file_unknown_architecture, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v1_file_unknown_architecture, "Test.tbd"));
   EXPECT_TRUE(!!Result);
 }
 
 TEST(TBDv1, UnknownPlatform) {
   static const char tbd_v1_file_unknown_platform[] = "---\n"
                                                      "archs: [ i386 ]\n"
                                                      "platform: newOS\n"
                                                      "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v1_file_unknown_platform, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v1_file_unknown_platform, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
             "newOS\n          ^~~~~\n",
             errorMessage);
 }
 
 TEST(TBDv1, MalformedFile1) {
   static const char malformed_file1[] = "---\n"
                                         "archs: [ arm64 ]\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file1, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
             "'platform'\narchs: [ arm64 ]\n^\n",
             errorMessage);
 }
 
 TEST(TBDv1, MalformedFile2) {
   static const char malformed_file2[] = "---\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file2, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file2, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ(
       "malformed file\nTest.tbd:5:9: error: unknown key 'foobar'\nfoobar: "
       "\"Unsupported key\"\n        ^~~~~~~~~~~~~~~~~\n",
       errorMessage);
 }
 
 } // end namespace TBDv1.

llvm/trunk/unittests/TextAPI/TextStubV2Tests.cpp

static const char tbd_v2_file1[] =
       "  - archs: [ armv7, armv7s, armv7k ]\n"
       "    symbols: [ _sym5 ]\n"
       "    objc-classes: [ _class3 ]\n"
       "    objc-ivars: [ _class1._ivar3 ]\n"
       "    weak-def-symbols: [ _weak3 ]\n"
       "    thread-local-symbols: [ _tlv3 ]\n"
       "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v2_file1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
static const char tbd_v2_file2[] =
       "undefineds:\n"
       "  - archs: [ armv7, armv7s, armv7k, arm64 ]\n"
       "    symbols: [ _undefSym1, _undefSym2, _undefSym3 ]\n"
       "    objc-classes: [ _undefClass1, _undefClass2 ]\n"
       "    objc-ivars: [ _undefClass1._ivar1, _undefClass1._ivar2 ]\n"
       "    weak-ref-symbols: [ _undefWeak1, _undefWeak2 ]\n"
       "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file2, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v2_file2, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());

 
 TEST(TBDv2, Platform_macOS) {
   static const char tbd_v1_platform_macos[] = "--- !tapi-tbd-v2\n"
                                               "archs: [ x86_64 ]\n"
                                               "platform: macosx\n"
                                               "install-name: Test.dylib\n"
                                               "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_macos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_macos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(PlatformKind::macOS, File->getPlatform());
 }
 
 TEST(TBDv2, Platform_iOS) {
   static const char tbd_v1_platform_ios[] = "--- !tapi-tbd-v2\n"
                                             "archs: [ arm64 ]\n"
                                             "platform: ios\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_ios, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_ios, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
 }
 
 TEST(TBDv2, Platform_watchOS) {
   static const char tbd_v1_platform_watchos[] = "--- !tapi-tbd-v2\n"
                                                 "archs: [ armv7k ]\n"
                                                 "platform: watchos\n"
                                                 "install-name: Test.dylib\n"
                                                 "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_watchos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_watchos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(PlatformKind::watchOS, File->getPlatform());
 }
 
 TEST(TBDv2, Platform_tvOS) {
   static const char tbd_v1_platform_tvos[] = "--- !tapi-tbd-v2\n"
                                              "archs: [ arm64 ]\n"
                                              "platform: tvos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_tvos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_tvos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(PlatformKind::tvOS, File->getPlatform());
 }
 
 TEST(TBDv2, Platform_bridgeOS) {
   static const char tbd_v1_platform_bridgeos[] = "--- !tapi-tbd-v2\n"
                                                  "archs: [ armv7k ]\n"
                                                  "platform: bridgeos\n"
                                                  "install-name: Test.dylib\n"
                                                  "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v1_platform_bridgeos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_bridgeos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(PlatformKind::bridgeOS, File->getPlatform());
 }
 
 TEST(TBDv2, Swift_1_0) {
   static const char tbd_v1_swift_1_0[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 1.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(1U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, Swift_1_1) {
   static const char tbd_v1_swift_1_1[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 1.1\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, Swift_2_0) {
   static const char tbd_v1_swift_2_0[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 2.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_2_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_2_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(3U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, Swift_3_0) {
   static const char tbd_v1_swift_3_0[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 3.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_3_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_3_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(4U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, Swift_4_0) {
   static const char tbd_v1_swift_4_0[] = "--- !tapi-tbd-v2\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-version: 4.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_4_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_4_0, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:5:16: error: invalid Swift ABI "
             "version.\nswift-version: 4.0\n               ^~~\n",
             errorMessage);
 }
 
 TEST(TBDv2, Swift_5) {
   static const char tbd_v1_swift_5[] = "--- !tapi-tbd-v2\n"
                                        "archs: [ arm64 ]\n"
                                        "platform: ios\n"
                                        "install-name: Test.dylib\n"
                                        "swift-version: 5\n"
                                        "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_5, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_5, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(5U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, Swift_99) {
   static const char tbd_v1_swift_99[] = "--- !tapi-tbd-v2\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "swift-version: 99\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_99, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_99, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
   EXPECT_EQ(99U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv2, UnknownArchitecture) {
   static const char tbd_v2_file_unknown_architecture[] =
       "--- !tapi-tbd-v2\n"
       "archs: [ foo ]\n"
       "platform: macosx\n"
       "install-name: Test.dylib\n"
       "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v2_file_unknown_architecture, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v2_file_unknown_architecture, "Test.tbd"));
   EXPECT_TRUE(!!Result);
 }
 
 TEST(TBDv2, UnknownPlatform) {
   static const char tbd_v2_file_unknown_platform[] = "--- !tapi-tbd-v2\n"
                                                      "archs: [ i386 ]\n"
                                                      "platform: newOS\n"
                                                      "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v2_file_unknown_platform, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v2_file_unknown_platform, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
             "newOS\n          ^~~~~\n",
             errorMessage);
 }
 
 TEST(TBDv2, MalformedFile1) {
   static const char malformed_file1[] = "--- !tapi-tbd-v2\n"
                                         "archs: [ arm64 ]\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file1, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
             "'platform'\narchs: [ arm64 ]\n^\n",
             errorMessage);
 }
 
 TEST(TBDv2, MalformedFile2) {
   static const char malformed_file2[] = "--- !tapi-tbd-v2\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file2, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file2, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ(
       "malformed file\nTest.tbd:5:9: error: unknown key 'foobar'\nfoobar: "
       "\"Unsupported key\"\n        ^~~~~~~~~~~~~~~~~\n",
       errorMessage);
 }
 
 } // namespace TBDv2

llvm/trunk/unittests/TextAPI/TextStubV3Tests.cpp

static const char tbd_v3_file1[] =
       "  - 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"
       "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v3_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v3_file1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   auto Archs = AK_armv7 | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   UUIDs uuids = {{AK_armv7, "00000000-0000-0000-0000-000000000000"},
                  {AK_arm64, "11111111-1111-1111-1111-111111111111"}};
   EXPECT_EQ(uuids, File->uuids());

 
 TEST(TBDv3, Platform_macOS) {
   static const char tbd_v1_platform_macos[] = "--- !tapi-tbd-v3\n"
                                               "archs: [ x86_64 ]\n"
                                               "platform: macosx\n"
                                               "install-name: Test.dylib\n"
                                               "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_macos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_macos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(PlatformKind::macOS, File->getPlatform());
 }
 
 TEST(TBDv3, Platform_iOS) {
   static const char tbd_v1_platform_ios[] = "--- !tapi-tbd-v3\n"
                                             "archs: [ arm64 ]\n"
                                             "platform: ios\n"
                                             "install-name: Test.dylib\n"
                                             "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_ios, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_ios, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
 }
 
 TEST(TBDv3, Platform_watchOS) {
   static const char tbd_v1_platform_watchos[] = "--- !tapi-tbd-v3\n"
                                                 "archs: [ armv7k ]\n"
                                                 "platform: watchos\n"
                                                 "install-name: Test.dylib\n"
                                                 "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_watchos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_watchos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(PlatformKind::watchOS, File->getPlatform());
 }
 
 TEST(TBDv3, Platform_tvOS) {
   static const char tbd_v1_platform_tvos[] = "--- !tapi-tbd-v3\n"
                                              "archs: [ arm64 ]\n"
                                              "platform: tvos\n"
                                              "install-name: Test.dylib\n"
                                              "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_platform_tvos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_tvos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(PlatformKind::tvOS, File->getPlatform());
 }
 
 TEST(TBDv3, Platform_bridgeOS) {
   static const char tbd_v1_platform_bridgeos[] = "--- !tapi-tbd-v3\n"
                                                  "archs: [ armv7k ]\n"
                                                  "platform: bridgeos\n"
                                                  "install-name: Test.dylib\n"
                                                  "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v1_platform_bridgeos, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_platform_bridgeos, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(PlatformKind::bridgeOS, File->getPlatform());
 }
 
 TEST(TBDv3, Swift_1_0) {
   static const char tbd_v1_swift_1_0[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 1.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(1U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, Swift_1_1) {
   static const char tbd_v1_swift_1_1[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 1.1\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_1_1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_1_1, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, Swift_2_0) {
   static const char tbd_v1_swift_2_0[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 2.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_2_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_2_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(3U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, Swift_3_0) {
   static const char tbd_v1_swift_3_0[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 3.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_3_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_3_0, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(4U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, Swift_4_0) {
   static const char tbd_v1_swift_4_0[] = "--- !tapi-tbd-v3\n"
                                          "archs: [ arm64 ]\n"
                                          "platform: ios\n"
                                          "install-name: Test.dylib\n"
                                          "swift-abi-version: 4.0\n"
                                          "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_4_0, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_4_0, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:5:20: error: invalid Swift ABI "
             "version.\nswift-abi-version: 4.0\n                   ^~~\n",
             errorMessage);
 }
 
 TEST(TBDv3, Swift_5) {
   static const char tbd_v1_swift_5[] = "--- !tapi-tbd-v3\n"
                                        "archs: [ arm64 ]\n"
                                        "platform: ios\n"
                                        "install-name: Test.dylib\n"
                                        "swift-abi-version: 5\n"
                                        "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_5, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_5, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(5U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, Swift_99) {
   static const char tbd_v1_swift_99[] = "--- !tapi-tbd-v3\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "swift-abi-version: 99\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_swift_99, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(tbd_v1_swift_99, "Test.tbd"));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V3, File->getFileType());
   EXPECT_EQ(99U, File->getSwiftABIVersion());
 }
 
 TEST(TBDv3, UnknownArchitecture) {
   static const char tbd_v3_file_unknown_architecture[] =
       "--- !tapi-tbd-v3\n"
       "archs: [ foo ]\n"
       "platform: macosx\n"
       "install-name: Test.dylib\n"
       "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v3_file_unknown_architecture, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v3_file_unknown_architecture, "Test.tbd"));
   EXPECT_TRUE(!!Result);
 }
 
 TEST(TBDv3, UnknownPlatform) {
   static const char tbd_v3_file_unknown_platform[] = "--- !tapi-tbd-v3\n"
                                                      "archs: [ i386 ]\n"
                                                      "platform: newOS\n"
                                                      "...\n";
 
-  auto Buffer =
-      MemoryBuffer::getMemBuffer(tbd_v3_file_unknown_platform, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result = TextAPIReader::get(
+      MemoryBufferRef(tbd_v3_file_unknown_platform, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   EXPECT_EQ("malformed file\nTest.tbd:3:11: error: unknown platform\nplatform: "
             "newOS\n          ^~~~~\n",
             errorMessage);
 }
 
 TEST(TBDv3, MalformedFile1) {
   static const char malformed_file1[] = "--- !tapi-tbd-v3\n"
                                         "archs: [ arm64 ]\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file1, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file1, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ("malformed file\nTest.tbd:2:1: error: missing required key "
             "'platform'\narchs: [ arm64 ]\n^\n",
             errorMessage);
 }
 
 TEST(TBDv3, MalformedFile2) {
   static const char malformed_file2[] = "--- !tapi-tbd-v3\n"
                                         "archs: [ arm64 ]\n"
                                         "platform: ios\n"
                                         "install-name: Test.dylib\n"
                                         "foobar: \"Unsupported key\"\n"
                                         "...\n";
 
-  auto Buffer = MemoryBuffer::getMemBuffer(malformed_file2, "Test.tbd");
-  auto Result = TextAPIReader::get(std::move(Buffer));
+  auto Result =
+      TextAPIReader::get(MemoryBufferRef(malformed_file2, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   auto errorMessage = toString(Result.takeError());
   ASSERT_EQ(
       "malformed file\nTest.tbd:5:9: error: unknown key 'foobar'\nfoobar: "
       "\"Unsupported key\"\n        ^~~~~~~~~~~~~~~~~\n",
       errorMessage);
 }
 
 } // namespace TBDv3