[Parse] Check the SourceFile to see if bodies can be delayed

Remove the `DelayBodyParsing` flag from the parser
and instead query the source file.

Author: hamishknight

include/swift/AST/SourceFile.h

@@ -569,6 +569,10 @@ class SourceFile final : public FileUnit {
 
   bool isSuitableForASTScopes() const { return canBeParsedInFull(); }
 
+  /// Whether the bodies of types and functions within this file can be lazily
+  /// parsed.
+  bool hasDelayedBodyParsing() const;
+
   syntax::SourceFileSyntax getSyntaxRoot() const;
   void setSyntaxRoot(syntax::SourceFileSyntax &&Root);
   bool hasSyntaxRoot() const;

include/swift/Parse/Parser.h

@@ -173,9 +173,9 @@ class Parser {
 
   LocalContext *CurLocalContext = nullptr;
 
-  bool isDelayedParsingEnabled() const {
-    return DelayBodyParsing || isCodeCompletionFirstPass();
-  }
+  /// Whether we should delay parsing nominal type, extension, and function
+  /// bodies.
+  bool isDelayedParsingEnabled() const;
 
   void setCodeCompletionCallbacks(CodeCompletionCallbacks *Callbacks) {
     CodeCompletion = Callbacks;
@@ -213,16 +213,6 @@ class Parser {
   /// Always empty if !SF.shouldBuildSyntaxTree().
   ParsedTrivia TrailingTrivia;
 
-  /// Whether we should delay parsing nominal type and extension bodies,
-  /// and skip function bodies.
-  ///
-  /// This is false in primary files, since we want to type check all
-  /// declarations and function bodies.
-  ///
-  /// This is true for non-primary files, where declarations only need to be
-  /// lazily parsed and type checked.
-  bool DelayBodyParsing;
-
   /// Whether to evaluate the conditions of #if decls, meaning that the bodies
   /// of any active clauses are hoisted such that they become sibling nodes with
   /// the #if decl.
@@ -408,16 +398,16 @@ class Parser {
          SILParserTUStateBase *SIL,
          PersistentParserState *PersistentState,
          std::shared_ptr<SyntaxParseActions> SPActions = nullptr,
-         bool DelayBodyParsing = true, bool EvaluateConditionals = true);
+         bool EvaluateConditionals = true);
   Parser(unsigned BufferID, SourceFile &SF, SILParserTUStateBase *SIL,
          PersistentParserState *PersistentState = nullptr,
          std::shared_ptr<SyntaxParseActions> SPActions = nullptr,
-         bool DelayBodyParsing = true, bool EvaluateConditionals = true);
+         bool EvaluateConditionals = true);
   Parser(std::unique_ptr<Lexer> Lex, SourceFile &SF,
          SILParserTUStateBase *SIL = nullptr,
          PersistentParserState *PersistentState = nullptr,
          std::shared_ptr<SyntaxParseActions> SPActions = nullptr,
-         bool DelayBodyParsing = true, bool EvaluateConditionals = true);
+         bool EvaluateConditionals = true);
   ~Parser();
 
   /// Returns true if the buffer being parsed is allowed to contain SIL.

include/swift/Subsystems.h

@@ -108,11 +108,7 @@ namespace swift {
   /// \param SF The file within the module being parsed.
   ///
   /// \param BufferID The buffer to parse from.
-  ///
-  /// \param DelayBodyParsing Whether parsing of type and function bodies can be
-  /// delayed.
   void parseIntoSourceFile(SourceFile &SF, unsigned BufferID,
-                           bool DelayBodyParsing = true,
                            bool EvaluateConditionals = true);
 
   /// Parse a source file's SIL declarations into a given SIL module.

lib/AST/Module.cpp

@@ -1954,6 +1954,23 @@ bool SourceFile::canBeParsedInFull() const {
   llvm_unreachable("unhandled kind");
 }
 
+bool SourceFile::hasDelayedBodyParsing() const {
+  if (ParsingOpts.contains(ParsingFlags::DisableDelayedBodies))
+    return false;
+
+  // Not supported right now.
+  if (Kind == SourceFileKind::REPL || Kind == SourceFileKind::SIL)
+    return false;
+  if (hasInterfaceHash())
+    return false;
+  if (shouldCollectToken())
+    return false;
+  if (shouldBuildSyntaxTree())
+    return false;
+
+  return true;
+}
+
 bool FileUnit::walk(ASTWalker &walker) {
   SmallVector<Decl *, 64> Decls;
   getTopLevelDecls(Decls);

lib/Frontend/Frontend.cpp

@@ -976,7 +976,7 @@ void CompilerInstance::parseLibraryFile(
   auto DidSuppressWarnings = Diags.getSuppressWarnings();
   Diags.setSuppressWarnings(DidSuppressWarnings || !IsPrimary);
 
-  parseIntoSourceFile(*NextInput, BufferID, /*DelayedBodyParsing=*/!IsPrimary);
+  parseIntoSourceFile(*NextInput, BufferID);
 
   Diags.setSuppressWarnings(DidSuppressWarnings);
 
@@ -1023,8 +1023,7 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
   Diags.setSuppressWarnings(DidSuppressWarnings || !mainIsPrimary);
 
   // Parse the Swift decls into the source file.
-  parseIntoSourceFile(MainFile, MainBufferID,
-                      /*delayBodyParsing*/ !mainIsPrimary);
+  parseIntoSourceFile(MainFile, MainBufferID);
 
   // For a primary, also perform type checking if needed. Otherwise, just do
   // name binding.
@@ -1139,14 +1138,6 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
                                   MainBufferID, parsingOpts);
   }
 
-  auto shouldDelayBodies = [&](unsigned bufferID) -> bool {
-    if (!CanDelayBodies)
-      return false;
-
-    // Don't delay bodies in whole module mode or for primary files.
-    return !(isWholeModuleCompilation() || isPrimaryInput(bufferID));
-  };
-
   // Parse all the library files.
   for (auto BufferID : InputSourceCodeBufferIDs) {
     if (BufferID == MainBufferID)
@@ -1156,8 +1147,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
         SourceFileKind::Library, SourceFile::ImplicitModuleImportKind::None,
         BufferID, parsingOpts);
 
-    parseIntoSourceFile(*NextInput, BufferID, shouldDelayBodies(BufferID),
-                        EvaluateConditionals);
+    parseIntoSourceFile(*NextInput, BufferID, EvaluateConditionals);
   }
 
   // Now parse the main file.
@@ -1167,8 +1157,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
     MainFile.SyntaxParsingCache = Invocation.getMainFileSyntaxParsingCache();
     assert(MainBufferID == MainFile.getBufferID());
 
-    parseIntoSourceFile(MainFile, MainBufferID, shouldDelayBodies(MainBufferID),
-                        EvaluateConditionals);
+    parseIntoSourceFile(MainFile, MainBufferID, EvaluateConditionals);
   }
 
   assert(Context->LoadedModules.size() == 1 &&

lib/Parse/ParseDecl.cpp

@@ -4569,7 +4569,7 @@ Parser::parseDeclList(SourceLoc LBLoc, SourceLoc &RBLoc, Diag<> ErrorDiag,
 bool Parser::canDelayMemberDeclParsing(bool &HasOperatorDeclarations,
                                        bool &HasNestedClassDeclarations) {
   // If explicitly disabled, respect the flag.
-  if (!DelayBodyParsing)
+  if (!isDelayedParsingEnabled())
     return false;
   // Recovering parser status later for #sourceLocation is not-trivial and
   // it may not worth it.
@@ -6449,7 +6449,10 @@ void Parser::parseAbstractFunctionBody(AbstractFunctionDecl *AFD) {
 
   llvm::SaveAndRestore<NullablePtr<llvm::MD5>> T(CurrentTokenHash, nullptr);
 
-  if (isDelayedParsingEnabled()) {
+  // If we can delay parsing this body, or this is the first pass of code
+  // completion, skip until the end. If we encounter a code completion token
+  // while skipping, we'll make a note of it.
+  if (isDelayedParsingEnabled() || isCodeCompletionFirstPass()) {
     consumeAbstractFunctionBody(AFD, AFD->getAttrs());
     return;
   }

lib/Parse/Parser.cpp

@@ -151,9 +151,6 @@ void Parser::performCodeCompletionSecondPassImpl(
   // Set the parser position to the start of the delayed decl or the body.
   restoreParserPosition(getParserPosition(startLoc, prevLoc));
 
-  // Do not delay parsing in the second pass.
-  llvm::SaveAndRestore<bool> DisableDelayedBody(DelayBodyParsing, false);
-
   // Re-enter the lexical scope.
   Scope S(this, info.takeScope());
 
@@ -366,15 +363,15 @@ static LexerMode sourceFileKindToLexerMode(SourceFileKind kind) {
 Parser::Parser(unsigned BufferID, SourceFile &SF, SILParserTUStateBase *SIL,
                PersistentParserState *PersistentState,
                std::shared_ptr<SyntaxParseActions> SPActions,
-               bool DelayBodyParsing, bool EvaluateConditionals)
+               bool EvaluateConditionals)
     : Parser(BufferID, SF, &SF.getASTContext().Diags, SIL, PersistentState,
-             std::move(SPActions), DelayBodyParsing, EvaluateConditionals) {}
+             std::move(SPActions), EvaluateConditionals) {}
 
 Parser::Parser(unsigned BufferID, SourceFile &SF, DiagnosticEngine* LexerDiags,
                SILParserTUStateBase *SIL,
                PersistentParserState *PersistentState,
                std::shared_ptr<SyntaxParseActions> SPActions,
-               bool DelayBodyParsing, bool EvaluateConditionals)
+               bool EvaluateConditionals)
     : Parser(
           std::unique_ptr<Lexer>(new Lexer(
               SF.getASTContext().LangOpts, SF.getASTContext().SourceMgr,
@@ -389,7 +386,7 @@ Parser::Parser(unsigned BufferID, SourceFile &SF, DiagnosticEngine* LexerDiags,
               SF.shouldBuildSyntaxTree()
                   ? TriviaRetentionMode::WithTrivia
                   : TriviaRetentionMode::WithoutTrivia)),
-          SF, SIL, PersistentState, std::move(SPActions), DelayBodyParsing,
+          SF, SIL, PersistentState, std::move(SPActions),
           EvaluateConditionals) {}
 
 namespace {
@@ -511,7 +508,7 @@ Parser::Parser(std::unique_ptr<Lexer> Lex, SourceFile &SF,
                SILParserTUStateBase *SIL,
                PersistentParserState *PersistentState,
                std::shared_ptr<SyntaxParseActions> SPActions,
-               bool DelayBodyParsing, bool EvaluateConditionals)
+               bool EvaluateConditionals)
   : SourceMgr(SF.getASTContext().SourceMgr),
     Diags(SF.getASTContext().Diags),
     SF(SF),
@@ -520,7 +517,6 @@ Parser::Parser(std::unique_ptr<Lexer> Lex, SourceFile &SF,
     CurDeclContext(&SF),
     Context(SF.getASTContext()),
     CurrentTokenHash(SF.getInterfaceHashPtr()),
-    DelayBodyParsing(DelayBodyParsing),
     EvaluateConditionals(EvaluateConditionals),
     TokReceiver(SF.shouldCollectToken() ?
                 new TokenRecorder(SF, L->getBufferID()) :
@@ -547,6 +543,14 @@ Parser::~Parser() {
 
 bool Parser::isInSILMode() const { return SF.Kind == SourceFileKind::SIL; }
 
+bool Parser::isDelayedParsingEnabled() const {
+  // Do not delay parsing during code completion's second pass.
+  if (CodeCompletion)
+    return false;
+
+  return SF.hasDelayedBodyParsing();
+}
+
 bool Parser::allowTopLevelCode() const {
   return SF.isScriptMode();
 }
@@ -1201,8 +1205,7 @@ ParserUnit::ParserUnit(SourceManager &SM, SourceFileKind SFKind, unsigned Buffer
 
   Impl.SF->SyntaxParsingCache = SyntaxCache;
   Impl.TheParser.reset(new Parser(BufferID, *Impl.SF, /*SIL=*/nullptr,
-                                  /*PersistentState=*/nullptr, Impl.SPActions,
-                                  /*DelayBodyParsing=*/false));
+                                  /*PersistentState=*/nullptr, Impl.SPActions));
 }
 
 ParserUnit::ParserUnit(SourceManager &SM, SourceFileKind SFKind, unsigned BufferID,
@@ -1219,7 +1222,7 @@ ParserUnit::ParserUnit(SourceManager &SM, SourceFileKind SFKind, unsigned Buffer
                       TriviaRetentionMode::WithoutTrivia,
                       Offset, EndOffset));
   Impl.TheParser.reset(new Parser(std::move(Lex), *Impl.SF, /*SIL=*/nullptr,
-    /*PersistentState=*/nullptr, Impl.SPActions, /*DelayBodyParsing=*/false));
+                                  /*PersistentState=*/nullptr, Impl.SPActions));
 }
 
 ParserUnit::~ParserUnit() {

lib/ParseSIL/ParseSIL.cpp

@@ -120,7 +120,6 @@ static void deletePersistentParserState(PersistentParserState *state) {
 }
 
 void swift::parseIntoSourceFile(SourceFile &SF, unsigned int BufferID,
-                                bool DelayBodyParsing,
                                 bool EvaluateConditionals) {
   auto &ctx = SF.getASTContext();
   std::shared_ptr<SyntaxTreeCreator> STreeCreator;
@@ -130,16 +129,6 @@ void swift::parseIntoSourceFile(SourceFile &SF, unsigned int BufferID,
         SF.SyntaxParsingCache, SF.getASTContext().getSyntaxArena());
   }
 
-  // Not supported right now.
-  if (SF.Kind == SourceFileKind::REPL)
-    DelayBodyParsing = false;
-  if (SF.hasInterfaceHash())
-    DelayBodyParsing = false;
-  if (SF.shouldCollectToken())
-    DelayBodyParsing = false;
-  if (SF.shouldBuildSyntaxTree())
-    DelayBodyParsing = false;
-
   // If this buffer is for code completion, hook up the state needed by its
   // second pass.
   PersistentParserState *state = nullptr;
@@ -150,7 +139,7 @@ void swift::parseIntoSourceFile(SourceFile &SF, unsigned int BufferID,
 
   FrontendStatsTracer tracer(SF.getASTContext().Stats,
                              "Parsing");
-  Parser P(BufferID, SF, /*SIL*/ nullptr, state, STreeCreator, DelayBodyParsing,
+  Parser P(BufferID, SF, /*SIL*/ nullptr, state, STreeCreator,
            EvaluateConditionals);
   PrettyStackTraceParser StackTrace(P);
 
@@ -172,7 +161,7 @@ void swift::parseSourceFileSIL(SourceFile &SF, SILParserState *sil) {
                              "Parsing SIL");
   Parser parser(*bufferID, SF, sil->Impl.get(),
                 /*persistentParserState*/ nullptr,
-                /*syntaxTreeCreator*/ nullptr, /*delayBodyParsing*/ false);
+                /*syntaxTreeCreator*/ nullptr);
   PrettyStackTraceParser StackTrace(parser);
   parser.parseTopLevelSIL();
 }