Merge pull request #12727 from nkcsgexi/revert-lib-syntax

Author: swift-ci

include/swift/AST/Module.h

@@ -83,7 +83,7 @@ namespace syntax {
   class SourceFileSyntax;
   class SyntaxParsingContext;
   class SyntaxParsingContextRoot;
-  struct RawSyntaxInfo;
+  struct RawTokenInfo;
 }
 
 /// Discriminator for file-units.
@@ -1092,7 +1092,7 @@ class SourceFile final : public FileUnit {
   Optional<std::vector<Token>> AllCorrectedTokens;
 
   /// All of the raw token syntax nodes in the underlying source.
-  std::vector<syntax::RawSyntaxInfo> AllRawTokenSyntax;
+  std::vector<syntax::RawTokenInfo> AllRawTokenSyntax;
 
   SourceFileSyntaxInfo &SyntaxInfo;
 

include/swift/Parse/Lexer.h

@@ -246,7 +246,7 @@ class Lexer {
   }
 
   /// Lex a full token including leading and trailing trivia.
-  syntax::RawSyntaxInfo fullLex();
+  syntax::RawTokenInfo fullLex();
 
   bool isKeepingComments() const {
     return RetainComments == CommentRetentionMode::ReturnAsTokens;

include/swift/Parse/Parser.h

@@ -1429,7 +1429,7 @@ tokenizeWithTrivia(const LangOptions &LangOpts,
 void populateTokenSyntaxMap(const LangOptions &LangOpts,
                             const SourceManager &SM,
                             unsigned BufferID,
-                            std::vector<syntax::RawSyntaxInfo> &Result);
+                            std::vector<syntax::RawTokenInfo> &Result);
 } // end namespace swift
 
 #endif

include/swift/Syntax/SyntaxParsingContext.h

@@ -23,30 +23,12 @@
 
 namespace swift {
   class SourceFile;
-  class Token;
 
 namespace syntax {
 
-/// The handler for parser to generate libSyntax entities.
-struct RawSyntaxInfo {
-  /// Start location of this syntax node.
-  SourceLoc StartLoc;
-
-  /// The number of tokens belong to the syntax node.
-  unsigned TokCount;
-
-  /// The raw node.
-  RC<RawSyntax> RawNode;
-  RawSyntaxInfo(SourceLoc StartLoc, RC<RawSyntax> RawNode):
-    RawSyntaxInfo(StartLoc, 1, RawNode) {}
-  RawSyntaxInfo(SourceLoc StartLoc, unsigned TokCount, RC<RawSyntax> RawNode);
-  template <typename SyntaxNode>
-  SyntaxNode makeSyntax() const { return make<SyntaxNode>(RawNode); }
-
-  template <typename RawSyntaxNode>
-  RC<RawSyntaxNode> getRaw() const {
-    return RC<RawSyntaxNode>(cast<RawSyntaxNode>(RawNode));
-  }
+struct RawTokenInfo {
+  SourceLoc Loc;
+  RC<RawTokenSyntax> Token;
 };
 
 enum class SyntaxParsingContextKind: uint8_t {
@@ -58,12 +40,11 @@ enum class SyntaxParsingContextKind: uint8_t {
 /// create syntax nodes.
 class SyntaxParsingContext {
 protected:
-  SyntaxParsingContext(SourceFile &SF, unsigned BufferID, Token &Tok);
+  SyntaxParsingContext(bool Enabled);
   SyntaxParsingContext(SyntaxParsingContext &Another);
 public:
   struct ContextInfo;
   ContextInfo &ContextData;
-  const Token &Tok;
 
   // Add a token syntax at the given source location to the context; this
   // token node can be used to build more complex syntax nodes in later call
@@ -85,10 +66,12 @@ class SyntaxParsingContext {
 // of all other entity-specific contexts. This is the context Parser
 // has when the parser instance is firstly created.
 class SyntaxParsingContextRoot: public SyntaxParsingContext {
-  SourceFile &File;
 public:
-  SyntaxParsingContextRoot(SourceFile &File, unsigned BufferID, Token &Tok):
-    SyntaxParsingContext(File, BufferID, Tok), File(File) {}
+  struct GlobalInfo;
+
+  // Contains global information of the source file under parsing.
+  GlobalInfo &GlobalData;
+  SyntaxParsingContextRoot(SourceFile &SF, unsigned BufferID);
   ~SyntaxParsingContextRoot();
   void addTokenSyntax(SourceLoc Loc) override {};
   void makeNode(SyntaxKind Kind) override {};
@@ -97,22 +80,21 @@ class SyntaxParsingContextRoot: public SyntaxParsingContext {
   };
 };
 
-enum class SyntaxContextKind: uint8_t{
-  Expr,
-  Decl,
-};
-
 // The base class for contexts that are created from a parent context.
 // The stack instance will set the context holder when the context
 // is firstly created and reset the context holder to the parent when
 // it's destructed.
 class SyntaxParsingContextChild: public SyntaxParsingContext {
   SyntaxParsingContext *Parent;
   SyntaxParsingContext *&ContextHolder;
-  const SyntaxContextKind Kind;
+  const SyntaxKind FinalKind;
 public:
   SyntaxParsingContextChild(SyntaxParsingContext *&ContextHolder,
-                            SyntaxContextKind Kind);
+                            SyntaxKind FinalKind):
+    SyntaxParsingContext(*ContextHolder), Parent(ContextHolder),
+    ContextHolder(ContextHolder), FinalKind(FinalKind) {
+      ContextHolder = this;
+  }
   ~SyntaxParsingContextChild();
   void makeNode(SyntaxKind Kind) override;
   void addTokenSyntax(SourceLoc Loc) override;

lib/Parse/Lexer.cpp

@@ -737,15 +737,15 @@ static bool rangeContainsPlaceholderEnd(const char *CurPtr,
   return false;
 }
 
-syntax::RawSyntaxInfo Lexer::fullLex() {
+syntax::RawTokenInfo Lexer::fullLex() {
   if (NextToken.isEscapedIdentifier()) {
     LeadingTrivia.push_back(syntax::TriviaPiece::backtick());
     TrailingTrivia.insert(TrailingTrivia.begin(),
                           syntax::TriviaPiece::backtick());
   }
   auto Loc = NextToken.getLoc();
   auto Result = syntax::RawTokenSyntax::make(NextToken.getKind(),
-                                        OwnedString(NextToken.getText()),
+                                        OwnedString(NextToken.getText()).copy(),
                                         syntax::SourcePresence::Present,
                                         {LeadingTrivia}, {TrailingTrivia});
   LeadingTrivia.clear();

lib/Parse/ParseDecl.cpp

@@ -37,7 +37,6 @@
 #include <algorithm>
 
 using namespace swift;
-using namespace syntax;
 
 namespace {
   /// A RAII object for deciding whether this DeclKind needs special
@@ -2147,8 +2146,7 @@ void Parser::delayParseFromBeginningToHere(ParserPosition BeginParserPosition,
 ParserResult<Decl>
 Parser::parseDecl(ParseDeclOptions Flags,
                   llvm::function_ref<void(Decl*)> Handler) {
-  SyntaxParsingContextChild DeclParsingContext(SyntaxContext,
-                                               SyntaxContextKind::Decl);
+
   if (Tok.is(tok::pound_if)) {
     auto IfConfigResult = parseIfConfig(
       [&](SmallVectorImpl<ASTNode> &Decls, bool IsActive) {

lib/Parse/ParseExpr.cpp

@@ -40,8 +40,7 @@ using namespace swift::syntax;
 /// \param isExprBasic Whether we're only parsing an expr-basic.
 ParserResult<Expr> Parser::parseExprImpl(Diag<> Message, bool isExprBasic) {
   // Start a context for creating expression syntax.
-  SyntaxParsingContextChild ExprParsingContext(SyntaxContext,
-                                               SyntaxContextKind::Expr);
+  SyntaxParsingContextChild ExprParsingContext(SyntaxContext, SyntaxKind::Expr);
 
   // If we are parsing a refutable pattern, check to see if this is the start
   // of a let/var/is pattern.  If so, parse it to an UnresolvedPatternExpr and
@@ -1805,8 +1804,7 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
   // Create a syntax node for string literal.
   SyntaxContext->addTokenSyntax(Tok.getLoc());
   SyntaxContext->makeNode(SyntaxKind::StringLiteralExpr);
-  SyntaxParsingContextChild LocalContext(SyntaxContext,
-                                         SyntaxContextKind::Expr);
+  SyntaxParsingContextChild LocalContext(SyntaxContext, SyntaxKind::Expr);
 
   // FIXME: Avoid creating syntax nodes for string interpolation.
   LocalContext.disable();

lib/Parse/Parser.cpp

@@ -268,7 +268,7 @@ swift::tokenizeWithTrivia(const LangOptions &LangOpts,
                         syntax::AbsolutePosition>> Tokens;
   syntax::AbsolutePosition RunningPos;
   do {
-    auto ThisToken = L.fullLex().getRaw<syntax::RawTokenSyntax>();
+    auto ThisToken = L.fullLex().Token;
     auto ThisTokenPos = ThisToken->accumulateAbsolutePosition(RunningPos);
     Tokens.push_back({ThisToken, ThisTokenPos});
   } while (Tokens.back().first->isNot(tok::eof));
@@ -279,15 +279,15 @@ swift::tokenizeWithTrivia(const LangOptions &LangOpts,
 void swift::populateTokenSyntaxMap(const LangOptions &LangOpts,
                                    const SourceManager &SM,
                                    unsigned BufferID,
-                                   std::vector<syntax::RawSyntaxInfo> &Result) {
+                                   std::vector<syntax::RawTokenInfo> &Result) {
   if (!Result.empty())
     return;
   Lexer L(LangOpts, SM, BufferID, /*Diags=*/nullptr, /*InSILMode=*/false,
           CommentRetentionMode::AttachToNextToken,
           TriviaRetentionMode::WithTrivia);
   do {
     Result.emplace_back(L.fullLex());
-    if (Result.back().getRaw<syntax::RawTokenSyntax>()->is(tok::eof))
+    if (Result.back().Token->is(tok::eof))
       return;
   } while (true);
 }
@@ -434,7 +434,7 @@ Parser::Parser(std::unique_ptr<Lexer> Lex, SourceFile &SF,
     TokReceiver(SF.shouldKeepTokens() ?
                 new TokenRecorder(SF) :
                 new ConsumeTokenReceiver()),
-    SyntaxContext(new syntax::SyntaxParsingContextRoot(SF, L->getBufferID(), Tok)) {
+    SyntaxContext(new syntax::SyntaxParsingContextRoot(SF, L->getBufferID())) {
 
   State = PersistentState;
   if (!State) {