Remove DelayedDeclLists from PersistentParserState

include/swift/Frontend/Frontend.h

@@ -607,14 +607,13 @@ class CompilerInstance {
   void performSema();
 
   /// Parses the input file but does no type-checking or module imports.
-  /// Note that this only supports parsing an invocation with a single file.
   void performParseOnly(bool EvaluateConditionals = false,
-                        bool ParseDelayedBodyOnEnd = false);
+                        bool CanDelayBodies = true);
 
   /// Parses and performs name binding on all input files.
   ///
-  /// Like a parse-only invocation, a single file is required. Unlike a
-  /// parse-only invocation, module imports will be processed.
+  /// This is similar to a parse-only invocation, but module imports will also
+  /// be processed.
   void performParseAndResolveImportsOnly();
 
   /// Performs mandatory, diagnostic, and optimization passes over the SIL.

include/swift/Parse/PersistentParserState.h

@@ -78,8 +78,6 @@ class PersistentParserState {
 
   std::unique_ptr<CodeCompletionDelayedDeclState> CodeCompletionDelayedDeclStat;
 
-  std::vector<IterableDeclContext *> DelayedDeclLists;
-
   /// The local context for all top-level code.
   TopLevelContext TopLevelCode;
 
@@ -112,10 +110,6 @@ class PersistentParserState {
     return std::move(CodeCompletionDelayedDeclStat);
   }
 
-  void delayDeclList(IterableDeclContext *D);
-
-  void parseAllDelayedDeclLists();
-
   TopLevelContext &getTopLevelContext() {
     return TopLevelCode;
   }

lib/Frontend/Frontend.cpp

@@ -1071,7 +1071,7 @@ SourceFile *CompilerInstance::createSourceFileForMainModule(
 }
 
 void CompilerInstance::performParseOnly(bool EvaluateConditionals,
-                                        bool ParseDelayedBodyOnEnd) {
+                                        bool CanDelayBodies) {
   const InputFileKind Kind = Invocation.getInputKind();
   ModuleDecl *const MainModule = getMainModule();
   Context->LoadedModules[MainModule->getName()] = MainModule;
@@ -1093,36 +1093,38 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
   }
 
   PersistentState = llvm::make_unique<PersistentParserState>();
+  PersistentState->PerformConditionEvaluation = EvaluateConditionals;
+
+  auto shouldDelayBodies = [&](unsigned bufferID) -> bool {
+    if (!CanDelayBodies)
+      return false;
 
-  SWIFT_DEFER {
-    if (ParseDelayedBodyOnEnd)
-      PersistentState->parseAllDelayedDeclLists();
+    // Don't delay bodies in whole module mode or for primary files.
+    return !(isWholeModuleCompilation() || isPrimaryInput(bufferID));
   };
-  PersistentState->PerformConditionEvaluation = EvaluateConditionals;
+
   // Parse all the library files.
   for (auto BufferID : InputSourceCodeBufferIDs) {
     if (BufferID == MainBufferID)
       continue;
 
-    auto IsPrimary = isWholeModuleCompilation() || isPrimaryInput(BufferID);
-
     SourceFile *NextInput = createSourceFileForMainModule(
         SourceFileKind::Library, SourceFile::ImplicitModuleImportKind::None,
         BufferID);
 
     parseIntoSourceFileFull(*NextInput, BufferID, PersistentState.get(),
-                            /*DelayBodyParsing=*/!IsPrimary);
+                            shouldDelayBodies(BufferID));
   }
 
   // Now parse the main file.
   if (MainBufferID != NO_SUCH_BUFFER) {
     SourceFile &MainFile =
         MainModule->getMainSourceFile(Invocation.getSourceFileKind());
     MainFile.SyntaxParsingCache = Invocation.getMainFileSyntaxParsingCache();
+    assert(MainBufferID == MainFile.getBufferID());
 
-    parseIntoSourceFileFull(MainFile, MainFile.getBufferID().getValue(),
-                            PersistentState.get(),
-                            /*DelayBodyParsing=*/false);
+    parseIntoSourceFileFull(MainFile, MainBufferID, PersistentState.get(),
+                            shouldDelayBodies(MainBufferID));
   }
 
   assert(Context->LoadedModules.size() == 1 &&

lib/FrontendTool/FrontendTool.cpp

@@ -1262,12 +1262,12 @@ static bool performCompile(CompilerInstance &Instance,
     return compileLLVMIR(Invocation, Instance, Stats);
 
   if (FrontendOptions::shouldActionOnlyParse(Action)) {
-    bool ParseDelayedDeclListsOnEnd =
-      Action == FrontendOptions::ActionType::DumpParse ||
-      Invocation.getDiagnosticOptions().VerifyMode != DiagnosticOptions::NoVerify;
+    // Disable delayed parsing of type and function bodies when we've been
+    // asked to dump the resulting AST.
+    bool CanDelayBodies = Action != FrontendOptions::ActionType::DumpParse;
     Instance.performParseOnly(/*EvaluateConditionals*/
                     Action == FrontendOptions::ActionType::EmitImportedModules,
-                              ParseDelayedDeclListsOnEnd);
+                              CanDelayBodies);
   } else if (Action == FrontendOptions::ActionType::ResolveImports) {
     Instance.performParseAndResolveImportsOnly();
   } else {

lib/Parse/ParseDecl.cpp

@@ -4441,8 +4441,6 @@ bool Parser::delayParsingDeclList(SourceLoc LBLoc, SourceLoc &RBLoc,
     RBLoc = Tok.getLoc();
     error = true;
   }
-
-  State->delayDeclList(IDC);
   return error;
 }
 

lib/Parse/PersistentParserState.cpp

@@ -50,12 +50,3 @@ void PersistentParserState::restoreCodeCompletionDelayedDeclState(
       ScopeInfo.saveCurrentScope(), other.StartOffset, other.EndOffset,
       other.PrevOffset));
 }
-
-void PersistentParserState::delayDeclList(IterableDeclContext *D) {
-  DelayedDeclLists.push_back(D);
-}
-
-void PersistentParserState::parseAllDelayedDeclLists() {
-  for (auto IDC : DelayedDeclLists)
-    IDC->loadAllMembers();
-}