[Serialization] Sink readMembers into its only caller.

The next commit is going to want to look at the container whose
members are being loaded.

include/swift/Serialization/ModuleFile.h

@@ -526,15 +526,6 @@ private:
                    GenericContext *genericDecl,
                    serialization::GenericEnvironmentID envID);
 
-  /// Populates the vector with members of a DeclContext from \c DeclTypeCursor.
-  ///
-  /// Returns true if there is an error.
-  ///
-  /// Note: this destroys the cursor's position in the stream. Furthermore,
-  /// because it reads from the cursor, it is not possible to reset the cursor
-  /// after reading. Nothing should ever follow a MEMBERS record.
-  bool readMembers(SmallVectorImpl<Decl *> &Members);
-
   /// Populates the protocol's default witness table.
   ///
   /// Returns true if there is an error.

lib/Serialization/Deserialization.cpp

@@ -1235,47 +1235,6 @@ GenericEnvironment *ModuleFile::getGenericEnvironment(
 ;
 }
 
-bool ModuleFile::readMembers(SmallVectorImpl<Decl *> &Members) {
-  using namespace decls_block;
-
-  auto entry = DeclTypeCursor.advance();
-  if (entry.Kind != llvm::BitstreamEntry::Record)
-    return true;
-
-  SmallVector<uint64_t, 16> memberIDBuffer;
-
-  unsigned kind = DeclTypeCursor.readRecord(entry.ID, memberIDBuffer);
-  assert(kind == MEMBERS);
-  (void)kind;
-
-  ArrayRef<uint64_t> rawMemberIDs;
-  decls_block::MembersLayout::readRecord(memberIDBuffer, rawMemberIDs);
-
-  if (rawMemberIDs.empty())
-    return false;
-
-  Members.reserve(rawMemberIDs.size());
-  for (DeclID rawID : rawMemberIDs) {
-    Expected<Decl *> D = getDeclChecked(rawID);
-    if (!D) {
-      if (!getContext().LangOpts.EnableDeserializationRecovery)
-        fatal(D.takeError());
-
-      // Silently drop the member if it had an override-related problem.
-      llvm::handleAllErrors(D.takeError(),
-          [](const OverrideError &) { /* expected */ },
-          [this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
-        fatal(std::move(unhandled));
-      });
-      continue;
-    }
-    assert(D.get() && "unchecked error deserializing next member");
-    Members.push_back(D.get());
-  }
-
-  return false;
-}
-
 bool ModuleFile::readDefaultWitnessTable(ProtocolDecl *proto) {
   using namespace decls_block;
 
@@ -2834,7 +2793,7 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
     if (!overridden) {
       llvm::handleAllErrors(overridden.takeError(),
           [](const XRefError &) { /* expected */ },
-          [this](std::unique_ptr<llvm::ErrorInfoBase> unhandled){
+          [this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
         fatal(std::move(unhandled));
       });
       return llvm::make_error<OverrideError>(name);
@@ -4432,28 +4391,61 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
   return typeOrOffset;
 }
 
-void ModuleFile::loadAllMembers(Decl *D, uint64_t contextData) {
+void ModuleFile::loadAllMembers(Decl *container, uint64_t contextData) {
-  PrettyStackTraceDecl trace("loading members for", D);
+  PrettyStackTraceDecl trace("loading members for", container);
   ++NumMemberListsLoaded;
 
+  IterableDeclContext *IDC;
+  if (auto *nominal = dyn_cast<NominalTypeDecl>(container))
+    IDC = nominal;
+  else
+    IDC = cast<ExtensionDecl>(container);
+
   BCOffsetRAII restoreOffset(DeclTypeCursor);
   DeclTypeCursor.JumpToBit(contextData);
-  SmallVector<Decl *, 16> members;
+  auto entry = DeclTypeCursor.advance();
-  bool Err = readMembers(members);
+  if (entry.Kind != llvm::BitstreamEntry::Record) {
-  assert(!Err && "unable to read members");
+    error();
-  (void)Err;
+    return;
+  }
 
-  IterableDeclContext *IDC;
+  SmallVector<uint64_t, 16> memberIDBuffer;
-  if (auto *nominal = dyn_cast<NominalTypeDecl>(D))
+
-    IDC = nominal;
+  unsigned kind = DeclTypeCursor.readRecord(entry.ID, memberIDBuffer);
-  else
+  assert(kind == decls_block::MEMBERS);
-    IDC = cast<ExtensionDecl>(D);
+  (void)kind;
+
+  ArrayRef<uint64_t> rawMemberIDs;
+  decls_block::MembersLayout::readRecord(memberIDBuffer, rawMemberIDs);
+
+  if (rawMemberIDs.empty())
+    return;
+
+  SmallVector<Decl *, 16> members;
+  members.reserve(rawMemberIDs.size());
+  for (DeclID rawID : rawMemberIDs) {
+    Expected<Decl *> next = getDeclChecked(rawID);
+    if (!next) {
+      if (!getContext().LangOpts.EnableDeserializationRecovery)
+        fatal(next.takeError());
+
+      // Silently drop the member if it had an override-related problem.
+      llvm::handleAllErrors(next.takeError(),
+          [](const OverrideError &) { /* expected */ },
+          [this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
+        fatal(std::move(unhandled));
+      });
+      continue;
+    }
+    assert(next.get() && "unchecked error deserializing next member");
+    members.push_back(next.get());
+  }
 
   for (auto member : members)
     IDC->addMember(member);
 
-  if (auto *proto = dyn_cast<ProtocolDecl>(D)) {
+  if (auto *proto = dyn_cast<ProtocolDecl>(container)) {
-    PrettyStackTraceDecl trace("reading default witness table for", D);
+    PrettyStackTraceDecl trace("reading default witness table for", proto);
     bool Err = readDefaultWitnessTable(proto);
     assert(!Err && "unable to read default witness table");
     (void)Err;