Merge pull request swiftlang#29741 from hamishknight/moving-states

Move PersistentParserState onto SourceFile

Author: hamishknight

include/swift/AST/SourceFile.h

@@ -18,6 +18,8 @@
 
 namespace swift {
 
+class PersistentParserState;
+
 /// A file containing Swift source code.
 ///
 /// This is a .swift or .sil file (or a virtual file, such as the contents of
@@ -154,6 +156,16 @@ class SourceFile final : public FileUnit {
   /// mechanism which is not SourceFile-dependent.)
   SeparatelyImportedOverlayMap separatelyImportedOverlays;
 
+  /// A pointer to PersistentParserState with a function reference to its
+  /// deleter to handle the fact that it's forward declared.
+  using ParserStatePtr =
+      std::unique_ptr<PersistentParserState, void (*)(PersistentParserState *)>;
+
+  /// Stores delayed parser state that code completion needs to be able to
+  /// resume parsing at the code completion token in the file.
+  ParserStatePtr DelayedParserState =
+      ParserStatePtr(/*ptr*/ nullptr, /*deleter*/ nullptr);
+
   friend ASTContext;
   friend Impl;
 
@@ -405,6 +417,20 @@ class SourceFile final : public FileUnit {
   /// Retrieve the scope that describes this source file.
   ASTScope &getScope();
 
+  /// Retrieves the previously set delayed parser state, asserting that it
+  /// exists.
+  PersistentParserState *getDelayedParserState() {
+    auto *state = DelayedParserState.get();
+    assert(state && "Didn't set any delayed parser state!");
+    return state;
+  }
+
+  /// Record delayed parser state for the source file. This is needed for code
+  /// completion's second pass.
+  void setDelayedParserState(ParserStatePtr &&state) {
+    DelayedParserState = std::move(state);
+  }
+
   SWIFT_DEBUG_DUMP;
   void dump(raw_ostream &os) const;
 

include/swift/Frontend/Frontend.h

@@ -400,8 +400,6 @@ class CompilerInstance {
   std::unique_ptr<Lowering::TypeConverter> TheSILTypes;
   std::unique_ptr<SILModule> TheSILModule;
 
-  std::unique_ptr<PersistentParserState> PersistentState;
-
   /// Null if no tracker.
   std::unique_ptr<DependencyTracker> DepTracker;
   /// If there is no stats output directory by the time the
@@ -431,6 +429,9 @@ class CompilerInstance {
   /// buffer will also have its buffer ID in PrimaryBufferIDs.
   std::vector<SourceFile *> PrimarySourceFiles;
 
+  /// The file that has been registered for code completion.
+  NullablePtr<SourceFile> CodeCompletionFile;
+
   /// Return whether there is an entry in PrimaryInputs for buffer \p BufID.
   bool isPrimaryInput(unsigned BufID) const {
     return PrimaryBufferIDs.count(BufID) != 0;
@@ -550,12 +551,13 @@ class CompilerInstance {
     return Invocation;
   }
 
-  bool hasPersistentParserState() const {
-    return bool(PersistentState);
-  }
+  /// If a code completion buffer has been set, returns the corresponding source
+  /// file.
+  NullablePtr<SourceFile> getCodeCompletionFile() { return CodeCompletionFile; }
 
-  PersistentParserState &getPersistentParserState() {
-    return *PersistentState.get();
+  /// Set a new file that we're performing code completion on.
+  void setCodeCompletionFile(SourceFile *file) {
+    CodeCompletionFile = file;
   }
 
 private:

include/swift/Parse/Parser.h

@@ -223,6 +223,13 @@ class Parser {
   /// 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.
+  // FIXME: When condition evaluation moves to a later phase, remove this bit
+  // and adjust the client call 'performParseOnly'.
+  bool EvaluateConditionals;
+
   /// The receiver to collect all consumed tokens.
   ConsumeTokenReceiver *TokReceiver;
 
@@ -401,16 +408,16 @@ class Parser {
          SILParserTUStateBase *SIL,
          PersistentParserState *PersistentState,
          std::shared_ptr<SyntaxParseActions> SPActions = nullptr,
-         bool DelayBodyParsing = true);
+         bool DelayBodyParsing = true, bool EvaluateConditionals = true);
   Parser(unsigned BufferID, SourceFile &SF, SILParserTUStateBase *SIL,
          PersistentParserState *PersistentState = nullptr,
          std::shared_ptr<SyntaxParseActions> SPActions = nullptr,
-         bool DelayBodyParsing = true);
+         bool DelayBodyParsing = 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 DelayBodyParsing = true, bool EvaluateConditionals = true);
   ~Parser();
 
   /// Returns true if the buffer being parsed is allowed to contain SIL.

include/swift/Parse/PersistentParserState.h

@@ -19,7 +19,6 @@
 
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Parse/LocalContext.h"
-#include "swift/Parse/ParserPosition.h"
 #include "swift/Parse/Scope.h"
 #include "llvm/ADT/DenseMap.h"
 
@@ -58,11 +57,6 @@ class CodeCompletionDelayedDeclState {
 
 /// Parser state persistent across multiple parses.
 class PersistentParserState {
-public:
-  // FIXME: When condition evaluation moves to a later phase, remove this bit
-  // and adjust the client call 'performParseOnly'.
-  bool PerformConditionEvaluation = true;
-private:
   swift::ScopeInfo ScopeInfo;
 
   std::unique_ptr<CodeCompletionDelayedDeclState> CodeCompletionDelayedDeclStat;
@@ -85,13 +79,17 @@ class PersistentParserState {
   void restoreCodeCompletionDelayedDeclState(
       const CodeCompletionDelayedDeclState &other);
 
-  bool hasCodeCompletionDelayedDeclState() {
+  bool hasCodeCompletionDelayedDeclState() const {
     return CodeCompletionDelayedDeclStat.get() != nullptr;
   }
 
   CodeCompletionDelayedDeclState &getCodeCompletionDelayedDeclState() {
     return *CodeCompletionDelayedDeclStat.get();
   }
+  const CodeCompletionDelayedDeclState &
+  getCodeCompletionDelayedDeclState() const {
+    return *CodeCompletionDelayedDeclStat.get();
+  }
 
   std::unique_ptr<CodeCompletionDelayedDeclState>
   takeCodeCompletionDelayedDeclState() {

include/swift/Subsystems.h

@@ -55,7 +55,6 @@ namespace swift {
   class ModuleDecl;
   typedef void *OpaqueSyntaxNode;
   class Parser;
-  class PersistentParserState;
   class SerializationOptions;
   class SILOptions;
   class SILModule;
@@ -110,20 +109,17 @@ namespace swift {
   ///
   /// \param BufferID The buffer to parse from.
   ///
-  /// \param PersistentState If non-null the same PersistentState object can be
-  /// used to save parser state for code completion.
-  ///
   /// \param DelayBodyParsing Whether parsing of type and function bodies can be
   /// delayed.
   void parseIntoSourceFile(SourceFile &SF, unsigned BufferID,
-                           PersistentParserState *PersistentState = nullptr,
-                           bool DelayBodyParsing = true);
+                           bool DelayBodyParsing = true,
+                           bool EvaluateConditionals = true);
 
   /// Parse a source file's SIL declarations into a given SIL module.
   void parseSourceFileSIL(SourceFile &SF, SILParserState *sil);
 
   /// Finish the code completion.
-  void performCodeCompletionSecondPass(PersistentParserState &PersistentState,
+  void performCodeCompletionSecondPass(SourceFile &SF,
                                        CodeCompletionCallbacksFactory &Factory);
 
   /// Lex and return a vector of tokens for the given buffer.

lib/Frontend/Frontend.cpp

@@ -906,8 +906,6 @@ void CompilerInstance::parseAndCheckTypesUpTo(
     const ImplicitImports &implicitImports, SourceFile::ASTStage_t limitStage) {
   FrontendStatsTracer tracer(getStatsReporter(), "parse-and-check-types");
 
-  PersistentState = std::make_unique<PersistentParserState>();
-
   bool hadLoadError = parsePartialModulesAndLibraryFiles(implicitImports);
   if (Invocation.isCodeCompletion()) {
     // When we are doing code completion, make sure to emit at least one
@@ -978,8 +976,7 @@ void CompilerInstance::parseLibraryFile(
   auto DidSuppressWarnings = Diags.getSuppressWarnings();
   Diags.setSuppressWarnings(DidSuppressWarnings || !IsPrimary);
 
-  parseIntoSourceFile(*NextInput, BufferID, PersistentState.get(),
-                      /*DelayedBodyParsing=*/!IsPrimary);
+  parseIntoSourceFile(*NextInput, BufferID, /*DelayedBodyParsing=*/!IsPrimary);
 
   Diags.setSuppressWarnings(DidSuppressWarnings);
 
@@ -1026,7 +1023,7 @@ void CompilerInstance::parseAndTypeCheckMainFileUpTo(
   Diags.setSuppressWarnings(DidSuppressWarnings || !mainIsPrimary);
 
   // Parse the Swift decls into the source file.
-  parseIntoSourceFile(MainFile, MainBufferID, PersistentState.get(),
+  parseIntoSourceFile(MainFile, MainBufferID,
                       /*delayBodyParsing*/ !mainIsPrimary);
 
   // For a primary, also perform type checking if needed. Otherwise, just do
@@ -1096,6 +1093,11 @@ SourceFile *CompilerInstance::createSourceFileForMainModule(
     recordPrimarySourceFile(inputFile);
   }
 
+  if (bufferID == SourceMgr.getCodeCompletionBufferID()) {
+    assert(!CodeCompletionFile && "Multiple code completion files?");
+    CodeCompletionFile = inputFile;
+  }
+
   return inputFile;
 }
 
@@ -1121,9 +1123,6 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
                                   MainBufferID);
   }
 
-  PersistentState = std::make_unique<PersistentParserState>();
-  PersistentState->PerformConditionEvaluation = EvaluateConditionals;
-
   auto shouldDelayBodies = [&](unsigned bufferID) -> bool {
     if (!CanDelayBodies)
       return false;
@@ -1141,8 +1140,8 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
         SourceFileKind::Library, SourceFile::ImplicitModuleImportKind::None,
         BufferID);
 
-    parseIntoSourceFile(*NextInput, BufferID, PersistentState.get(),
-                        shouldDelayBodies(BufferID));
+    parseIntoSourceFile(*NextInput, BufferID, shouldDelayBodies(BufferID),
+                        EvaluateConditionals);
   }
 
   // Now parse the main file.
@@ -1152,16 +1151,15 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
     MainFile.SyntaxParsingCache = Invocation.getMainFileSyntaxParsingCache();
     assert(MainBufferID == MainFile.getBufferID());
 
-    parseIntoSourceFile(MainFile, MainBufferID, PersistentState.get(),
-                        shouldDelayBodies(MainBufferID));
+    parseIntoSourceFile(MainFile, MainBufferID, shouldDelayBodies(MainBufferID),
+                        EvaluateConditionals);
   }
 
   assert(Context->LoadedModules.size() == 1 &&
          "Loaded a module during parse-only");
 }
 
 void CompilerInstance::freeASTContext() {
-  PersistentState.reset();
   TheSILTypes.reset();
   Context.reset();
   MainModule = nullptr;