Merge pull request #26991 from DougGregor/delay-parsing-more-often

Author: swift-ci

include/swift/Frontend/Frontend.h

@@ -616,7 +616,6 @@ class CompilerInstance {
 
 private:
   void createREPLFile(const ImplicitImports &implicitImports);
-  std::unique_ptr<DelayedParsingCallbacks> computeDelayedParsingCallback();
 
   void addMainFileToModule(const ImplicitImports &implicitImports);
 
@@ -625,20 +624,17 @@ class CompilerInstance {
                               SourceFile::ASTStage_t LimitStage);
 
   void parseLibraryFile(unsigned BufferID,
-                        const ImplicitImports &implicitImports,
-                        DelayedParsingCallbacks *DelayedCB);
+                        const ImplicitImports &implicitImports);
 
   /// Return true if had load error
   bool
-  parsePartialModulesAndLibraryFiles(const ImplicitImports &implicitImports,
-                                     DelayedParsingCallbacks *DelayedCB);
+  parsePartialModulesAndLibraryFiles(const ImplicitImports &implicitImports);
 
   OptionSet<TypeCheckingFlags> computeTypeCheckingOptions();
 
   void forEachFileToTypeCheck(llvm::function_ref<void(SourceFile &)> fn);
 
   void parseAndTypeCheckMainFileUpTo(SourceFile::ASTStage_t LimitStage,
-                                     DelayedParsingCallbacks *DelayedParseCB,
                                      OptionSet<TypeCheckingFlags> TypeCheckOptions);
 
   void finishTypeChecking(OptionSet<TypeCheckingFlags> TypeCheckOptions);

include/swift/Parse/DelayedParsingCallbacks.h

@@ -46,7 +46,6 @@ namespace llvm {
 namespace swift {
   class CodeCompletionCallbacks;
   class DefaultArgumentInitializer;
-  class DelayedParsingCallbacks;
   class DiagnosticEngine;
   class Expr;
   class Lexer;
@@ -165,14 +164,8 @@ class Parser {
 
   LocalContext *CurLocalContext = nullptr;
 
-  DelayedParsingCallbacks *DelayedParseCB = nullptr;
-
   bool isDelayedParsingEnabled() const {
-    return DelayBodyParsing || DelayedParseCB != nullptr;
-  }
-
-  void setDelayedParsingCallbacks(DelayedParsingCallbacks *DelayedParseCB) {
-    this->DelayedParseCB = DelayedParseCB;
+    return DelayBodyParsing || SourceMgr.getCodeCompletionLoc().isValid();
   }
 
   void setCodeCompletionCallbacks(CodeCompletionCallbacks *Callbacks) {

include/swift/Parse/Parser.h

@@ -43,7 +43,6 @@ namespace swift {
   class CodeCompletionCallbacksFactory;
   class Decl;
   class DeclContext;
-  class DelayedParsingCallbacks;
   class DiagnosticConsumer;
   class DiagnosticEngine;
   class Evaluator;
@@ -114,23 +113,29 @@ namespace swift {
   /// \param PersistentState if non-null the same PersistentState object can
   /// be used to resume parsing or parse delayed function bodies.
   ///
-  /// \param DelayedParseCB if non-null enables delayed parsing for function
-  /// bodies.
-  ///
   /// \return true if the parser found code with side effects.
   bool parseIntoSourceFile(SourceFile &SF, unsigned BufferID, bool *Done,
                            SILParserState *SIL = nullptr,
                            PersistentParserState *PersistentState = nullptr,
-                           DelayedParsingCallbacks *DelayedParseCB = nullptr,
                            bool DelayBodyParsing = true);
 
+  /// DEPRECATED: Only used to break LLDB/Swift dependency.
+  inline
+  bool parseIntoSourceFile(SourceFile &SF, unsigned BufferID, bool *Done,
+                           SILParserState *SIL,
+                           PersistentParserState *PersistentState,
+                           std::nullptr_t,
+                           bool DelayBodyParsing) {
+    return parseIntoSourceFile(SF, BufferID, Done, SIL, PersistentState,
+                               DelayBodyParsing);
+  }
+
   /// Parse a single buffer into the given source file, until the full source
   /// contents are parsed.
   ///
   /// \return true if the parser found code with side effects.
   bool parseIntoSourceFileFull(SourceFile &SF, unsigned BufferID,
-                             PersistentParserState *PersistentState = nullptr,
-                             DelayedParsingCallbacks *DelayedParseCB = nullptr,
+                               PersistentParserState *PersistentState = nullptr,
                                bool DelayBodyParsing = true);
 
   /// Finish the parsing by going over the nodes that were delayed

include/swift/Subsystems.h

@@ -35,6 +35,9 @@ void SourceManager::verifyAllBuffers() const {
 }
 
 SourceLoc SourceManager::getCodeCompletionLoc() const {
+  if (CodeCompletionBufferID == 0U)
+    return SourceLoc();
+
   return getLocForBufferStart(CodeCompletionBufferID)
       .getAdvancedLoc(CodeCompletionOffset);
 }

lib/Basic/SourceLoc.cpp

@@ -24,7 +24,6 @@
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Frontend/ParseableInterfaceModuleLoader.h"
-#include "swift/Parse/DelayedParsingCallbacks.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -758,14 +757,6 @@ void CompilerInstance::createREPLFile(const ImplicitImports &implicitImports) {
   addAdditionalInitialImportsTo(SingleInputFile, implicitImports);
 }
 
-std::unique_ptr<DelayedParsingCallbacks>
-CompilerInstance::computeDelayedParsingCallback() {
-  if (Invocation.isCodeCompletion())
-    return llvm::make_unique<CodeCompleteDelayedCallbacks>(
-        SourceMgr.getCodeCompletionLoc());
-  return nullptr;
-}
-
 void CompilerInstance::addMainFileToModule(
     const ImplicitImports &implicitImports) {
   auto *MainFile = createSourceFileForMainModule(
@@ -776,13 +767,10 @@ void CompilerInstance::addMainFileToModule(
 void CompilerInstance::parseAndCheckTypesUpTo(
     const ImplicitImports &implicitImports, SourceFile::ASTStage_t limitStage) {
   FrontendStatsTracer tracer(Context->Stats, "parse-and-check-types");
-  std::unique_ptr<DelayedParsingCallbacks> DelayedCB{
-      computeDelayedParsingCallback()};
 
   PersistentState = llvm::make_unique<PersistentParserState>();
 
-  bool hadLoadError = parsePartialModulesAndLibraryFiles(
-      implicitImports, DelayedCB.get());
+  bool hadLoadError = parsePartialModulesAndLibraryFiles(implicitImports);
   if (Invocation.isCodeCompletion()) {
     // When we are doing code completion, make sure to emit at least one
     // diagnostic, so that ASTContext is marked as erroneous.  In this case
@@ -800,7 +788,7 @@ void CompilerInstance::parseAndCheckTypesUpTo(
   // In addition, the main file has parsing and type-checking
   // interwined.
   if (MainBufferID != NO_SUCH_BUFFER) {
-    parseAndTypeCheckMainFileUpTo(limitStage, DelayedCB.get(), TypeCheckOptions);
+    parseAndTypeCheckMainFileUpTo(limitStage, TypeCheckOptions);
   }
 
   assert(llvm::all_of(MainModule->getFiles(), [](const FileUnit *File) -> bool {
@@ -846,8 +834,7 @@ void CompilerInstance::parseAndCheckTypesUpTo(
 }
 
 void CompilerInstance::parseLibraryFile(
-    unsigned BufferID, const ImplicitImports &implicitImports,
-    DelayedParsingCallbacks *DelayedCB) {
+    unsigned BufferID, const ImplicitImports &implicitImports) {
   FrontendStatsTracer tracer(Context->Stats, "parse-library-file");
 
   auto *NextInput = createSourceFileForMainModule(
@@ -865,7 +852,7 @@ void CompilerInstance::parseLibraryFile(
     // Parser may stop at some erroneous constructions like #else, #endif
     // or '}' in some cases, continue parsing until we are done
     parseIntoSourceFile(*NextInput, BufferID, &Done, nullptr,
-                        PersistentState.get(), DelayedCB,
+                        PersistentState.get(),
                         /*DelayedBodyParsing=*/!IsPrimary);
   } while (!Done);
 
@@ -893,8 +880,7 @@ OptionSet<TypeCheckingFlags> CompilerInstance::computeTypeCheckingOptions() {
 }
 
 bool CompilerInstance::parsePartialModulesAndLibraryFiles(
-    const ImplicitImports &implicitImports,
-    DelayedParsingCallbacks *DelayedCB) {
+    const ImplicitImports &implicitImports) {
   FrontendStatsTracer tracer(Context->Stats,
                              "parse-partial-modules-and-library-files");
   bool hadLoadError = false;
@@ -910,15 +896,14 @@ bool CompilerInstance::parsePartialModulesAndLibraryFiles(
   // Then parse all the library files.
   for (auto BufferID : InputSourceCodeBufferIDs) {
     if (BufferID != MainBufferID) {
-      parseLibraryFile(BufferID, implicitImports, DelayedCB);
+      parseLibraryFile(BufferID, implicitImports);
     }
   }
   return hadLoadError;
 }
 
 void CompilerInstance::parseAndTypeCheckMainFileUpTo(
     SourceFile::ASTStage_t LimitStage,
-    DelayedParsingCallbacks *DelayedParseCB,
     OptionSet<TypeCheckingFlags> TypeCheckOptions) {
   FrontendStatsTracer tracer(Context->Stats,
                              "parse-and-typecheck-main-file");
@@ -942,7 +927,7 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
     // with 'sil' definitions.
     parseIntoSourceFile(MainFile, MainFile.getBufferID().getValue(), &Done,
                         TheSILModule ? &SILContext : nullptr,
-                        PersistentState.get(), DelayedParseCB,
+                        PersistentState.get(),
                         /*DelayedBodyParsing=*/false);
 
     if (mainIsPrimary && (Done || CurTUElem < MainFile.Decls.size())) {
@@ -1069,7 +1054,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
         BufferID);
 
     parseIntoSourceFileFull(*NextInput, BufferID, PersistentState.get(),
-                            nullptr, /*DelayBodyParsing=*/!IsPrimary);
+                            /*DelayBodyParsing=*/!IsPrimary);
   }
 
   // Now parse the main file.
@@ -1079,7 +1064,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
     MainFile.SyntaxParsingCache = Invocation.getMainFileSyntaxParsingCache();
 
     parseIntoSourceFileFull(MainFile, MainFile.getBufferID().getValue(),
-                            PersistentState.get(), nullptr,
+                            PersistentState.get(),
                             /*DelayBodyParsing=*/false);
   }
 

lib/Frontend/Frontend.cpp

@@ -20,7 +20,6 @@
 #include "swift/AST/Module.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceManager.h"
-#include "swift/Parse/DelayedParsingCallbacks.h"
 #include "swift/Parse/Parser.h"
 #include "swift/IDE/CodeCompletion.h"
 #include "swift/Subsystems.h"
@@ -208,12 +207,9 @@ doCodeCompletion(SourceFile &SF, StringRef EnteredCode, unsigned *BufferID,
   const unsigned OriginalDeclCount = SF.Decls.size();
 
   PersistentParserState PersistentState;
-  std::unique_ptr<DelayedParsingCallbacks> DelayedCB(
-      new CodeCompleteDelayedCallbacks(Ctx.SourceMgr.getCodeCompletionLoc()));
   bool Done;
   do {
-    parseIntoSourceFile(SF, *BufferID, &Done, nullptr, &PersistentState,
-                        DelayedCB.get());
+    parseIntoSourceFile(SF, *BufferID, &Done, nullptr, &PersistentState);
   } while (!Done);
   performTypeChecking(SF, PersistentState.getTopLevelContext(), None,
                       OriginalDeclCount);

lib/IDE/REPLCodeCompletion.cpp

@@ -16,7 +16,6 @@
 
 #include "swift/Parse/Parser.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
-#include "swift/Parse/DelayedParsingCallbacks.h"
 #include "swift/Parse/ParsedSyntaxRecorder.h"
 #include "swift/Parse/ParseSILSupport.h"
 #include "swift/Parse/SyntaxParsingContext.h"
@@ -5387,9 +5386,8 @@ void Parser::consumeAbstractFunctionBody(AbstractFunctionDecl *AFD,
 
   BodyRange.End = PreviousLoc;
 
-  if (DelayedParseCB &&
-      DelayedParseCB->shouldDelayFunctionBodyParsing(*this, AFD, Attrs,
-                                                     BodyRange)) {
+  if (SourceMgr.getCodeCompletionLoc().isInvalid() ||
+      SourceMgr.rangeContainsCodeCompletionLoc(BodyRange)) {
     AFD->setBodyDelayed(BodyRange);
   } else {
     AFD->setBodySkipped(BodyRange);

lib/Parse/ParseDecl.cpp

@@ -74,14 +74,12 @@ BraceStmt *ParseAbstractFunctionBodyRequest::evaluate(
   }
 
   case BodyKind::Unparsed: {
-    // FIXME: It should be fine to delay body parsing of local functions, so
-    // the DelayBodyParsing should go away entirely
     // FIXME: How do we configure code completion?
     SourceFile &sf = *afd->getDeclContext()->getParentSourceFile();
     SourceManager &sourceMgr = sf.getASTContext().SourceMgr;
     unsigned bufferID = sourceMgr.findBufferContainingLoc(afd->getLoc());
     Parser parser(bufferID, sf, static_cast<SILParserTUStateBase *>(nullptr),
-                  nullptr, nullptr, /*DelayBodyParsing=*/false);
+                  nullptr, nullptr);
     parser.SyntaxContext->setDiscard();
     auto body = parser.parseAbstractFunctionBodyDelayed(afd);
     afd->setBodyKind(BodyKind::Parsed);

lib/Parse/ParseRequests.cpp

@@ -25,7 +25,6 @@
 #include "swift/Basic/Timer.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
-#include "swift/Parse/DelayedParsingCallbacks.h"
 #include "swift/Parse/ParsedSyntaxNodes.h"
 #include "swift/Parse/ParsedSyntaxRecorder.h"
 #include "swift/Parse/ParseSILSupport.h"
@@ -112,7 +111,6 @@ void tokenize(const LangOptions &LangOpts, const SourceManager &SM,
 using namespace swift;
 using namespace swift::syntax;
 
-void DelayedParsingCallbacks::anchor() { }
 void SILParserTUStateBase::anchor() { }
 
 namespace {