[Parse] Remove delayed parsing for accessor decls

Now that, parsing accessor body is done by 'parseAbstractFunctionBody()'
which automatically handles delayed parsing by `delayFunctionBodyParsing()`.
So we no longer use delayed parsing facilities specific for accessor body.

Author: rintaro

include/swift/Parse/PersistentParserState.h

@@ -52,23 +52,6 @@ class PersistentParserState {
     {}
   };
 
-  class AccessorBodyState {
-    ParserPos BodyPos;
-    SavedScope Scope;
-    SourceLoc LBLoc;
-    friend class Parser;
-
-    SavedScope takeScope() {
-      return std::move(Scope);
-    }
-
-  public:
-    AccessorBodyState(SourceRange BodyRange, SourceLoc PreviousLoc,
-                      SavedScope &&Scope, SourceLoc LBLoc)
-        : BodyPos{BodyRange.Start, PreviousLoc}, Scope(std::move(Scope)),
-          LBLoc(LBLoc) {}
-  };
-
   enum class DelayedDeclKind {
     TopLevelCodeDecl,
     Decl,
@@ -109,11 +92,6 @@ class PersistentParserState {
                      std::unique_ptr<FunctionBodyState>>;
   DelayedFunctionBodiesTy DelayedFunctionBodies;
 
-  using DelayedAccessorBodiesTy =
-      llvm::DenseMap<AbstractFunctionDecl *,
-                     std::unique_ptr<AccessorBodyState>>;
-  DelayedAccessorBodiesTy DelayedAccessorBodies;
-
   /// \brief Parser sets this if it stopped parsing before the buffer ended.
   ParserPosition MarkedPos;
 
@@ -133,13 +111,6 @@ class PersistentParserState {
 
   bool hasFunctionBodyState(AbstractFunctionDecl *AFD);
 
-  void delayAccessorBodyParsing(AbstractFunctionDecl *AFD,
-                                SourceRange BodyRange,
-                                SourceLoc PreviousLoc,
-                                SourceLoc LBLoc);
-  std::unique_ptr<AccessorBodyState>
-  takeAccessorBodyState(AbstractFunctionDecl *AFD);
-
   void delayDecl(DelayedDeclKind Kind, unsigned Flags,
                  DeclContext *ParentContext,
                  SourceRange BodyRange, SourceLoc PreviousLoc);

lib/Parse/ParseDecl.cpp

@@ -3917,31 +3917,6 @@ static unsigned skipBracedBlock(Parser &P,
   return OpenBraces;
 }
 
-void Parser::consumeGetSetBody(AbstractFunctionDecl *AFD,
-                               SourceLoc LBLoc) {
-  SourceLoc SavedPreviousLoc = PreviousLoc;
-
-  SourceRange BodyRange;
-  BodyRange.Start = Tok.getLoc();
-
-  // Skip until the next '}' at the correct nesting level.
-  unsigned OpenBraces = skipUntilMatchingRBrace(*this, SyntaxContext);
-
-  if (OpenBraces != 1) {
-    // FIXME: implement some error recovery?
-  }
-
-  BodyRange.End = PreviousLoc;
-
-  if (DelayedParseCB->shouldDelayFunctionBodyParsing(
-          *this, AFD, AFD->getAttrs(), BodyRange)) {
-    State->delayAccessorBodyParsing(AFD, BodyRange, SavedPreviousLoc, LBLoc);
-    AFD->setBodyDelayed(BodyRange);
-  } else {
-    AFD->setBodySkipped(BodyRange);
-  }
-}
-
 /// Returns a descriptive name for the given accessor/addressor kind.
 static StringRef getAccessorNameForDiagnostic(AccessorKind accessorKind,
                                               AddressorKind addressorKind,
@@ -4262,46 +4237,6 @@ bool Parser::parseGetSet(ParseDeclOptions Flags,
   return Invalid;
 }
 
-void Parser::parseAccessorBodyDelayed(AbstractFunctionDecl *AFD) {
-  assert(!AFD->getBody() && "function should not have a parsed body");
-  assert(AFD->getBodyKind() == AbstractFunctionDecl::BodyKind::Unparsed &&
-         "function body should be delayed");
-
-  auto AccessorParserState = State->takeAccessorBodyState(AFD);
-  assert(AccessorParserState.get() && "should have a valid state");
-
-  auto BeginParserPosition = getParserPosition(AccessorParserState->BodyPos);
-  auto EndLexerState = L->getStateForEndOfTokenLoc(AFD->getEndLoc());
-
-  // ParserPositionRAII needs a primed parser to restore to.
-  if (Tok.is(tok::NUM_TOKENS))
-    consumeTokenWithoutFeedingReceiver();
-
-  // Ensure that we restore the parser state at exit.
-  ParserPositionRAII PPR(*this);
-
-  // Create a lexer that cannot go past the end state.
-  Lexer LocalLex(*L, BeginParserPosition.LS, EndLexerState);
-
-  // Temporarily swap out the parser's current lexer with our new one.
-  llvm::SaveAndRestore<Lexer *> T(L, &LocalLex);
-
-  // Rewind to the first token of the accessor body.
-  restoreParserPosition(BeginParserPosition);
-
-  // Re-enter the lexical scope.
-  Scope S(this, AccessorParserState->takeScope());
-  ParseFunctionBody CC(*this, AFD);
-  setLocalDiscriminatorToParamList(AFD->getParameters());
-
-  SmallVector<ASTNode, 16> Entries;
-  parseBraceItems(Entries);
-  BraceStmt *Body =
-      BraceStmt::create(Context, AccessorParserState->LBLoc, Entries,
-                        Tok.getLoc());
-  AFD->setBody(Body);
-}
-
 static void fillInAccessorTypeErrors(Parser &P, FuncDecl *accessor,
                                      AccessorKind kind) {
   if (!accessor) return;

lib/Parse/PersistentParserState.cpp

@@ -45,28 +45,6 @@ bool PersistentParserState::hasFunctionBodyState(AbstractFunctionDecl *AFD) {
   return DelayedFunctionBodies.find(AFD) != DelayedFunctionBodies.end();
 }
 
-void PersistentParserState::delayAccessorBodyParsing(AbstractFunctionDecl *AFD,
-                                                     SourceRange BodyRange,
-                                                     SourceLoc PreviousLoc,
-                                                     SourceLoc LBLoc) {
-  std::unique_ptr<AccessorBodyState> State;
-  State.reset(new AccessorBodyState(BodyRange, PreviousLoc,
-                                    ScopeInfo.saveCurrentScope(), LBLoc));
-  assert(DelayedAccessorBodies.find(AFD) == DelayedAccessorBodies.end() &&
-         "Already recorded state for this body");
-  DelayedAccessorBodies[AFD] = std::move(State);
-}
-
-std::unique_ptr<PersistentParserState::AccessorBodyState>
-PersistentParserState::takeAccessorBodyState(AbstractFunctionDecl *AFD) {
-  assert(AFD->getBodyKind() == AbstractFunctionDecl::BodyKind::Unparsed);
-  DelayedAccessorBodiesTy::iterator I = DelayedAccessorBodies.find(AFD);
-  assert(I != DelayedAccessorBodies.end() && "State should be saved");
-  std::unique_ptr<AccessorBodyState> State = std::move(I->second);
-  DelayedAccessorBodies.erase(I);
-  return State;
-}
-
 void PersistentParserState::delayDecl(DelayedDeclKind Kind,
                                       unsigned Flags,
                                       DeclContext *ParentContext,