[Parse] Optimize syntax parsing: Make ParsedRawSyntaxNode a POD type

This eliminates the overhead of ParsedRawSyntaxNode needing to do memory management.
If ParsedRawSyntaxNode needs to point to some data the memory is allocated from a bump allocator.

There are also some improvements on how the ParsedSyntaxBuilders work.

Author: akyrtzi

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -22,6 +22,7 @@
 namespace swift {
 
 typedef void *OpaqueSyntaxNode;
+class SyntaxParsingContext;
 
 /// Represents a raw syntax node formed by the parser.
 ///
@@ -50,12 +51,14 @@ class ParsedRawSyntaxNode {
     CharSourceRange Range;
   };
   struct DeferredLayoutNode {
-    std::vector<ParsedRawSyntaxNode> Children;
+    ArrayRef<ParsedRawSyntaxNode> Children;
   };
   struct DeferredTokenNode {
-    Token Tok;
-    ParsedTrivia LeadingTrivia;
-    ParsedTrivia TrailingTrivia;
+    const ParsedTriviaPiece *TriviaPieces;
+    SourceLoc TokLoc;
+    unsigned TokLength;
+    uint16_t NumLeadingTrivia;
+    uint16_t NumTrailingTrivia;
   };
 
   union {
@@ -77,16 +80,22 @@ class ParsedRawSyntaxNode {
     assert(getKind() == k && "Syntax kind with too large value!");
   }
 
-  ParsedRawSyntaxNode(Token tok,
-                      ParsedTrivia leadingTrivia,
-                      ParsedTrivia trailingTrivia)
-    : DeferredToken{std::move(tok),
-                    std::move(leadingTrivia),
-                    std::move(trailingTrivia)},
+  ParsedRawSyntaxNode(tok tokKind, SourceLoc tokLoc, unsigned tokLength,
+                      const ParsedTriviaPiece *triviaPieces,
+                      unsigned numLeadingTrivia,
+                      unsigned numTrailingTrivia)
+    : DeferredToken{triviaPieces,
+                    tokLoc, tokLength,
+                    uint16_t(numLeadingTrivia),
+                    uint16_t(numTrailingTrivia)},
       SynKind(uint16_t(syntax::SyntaxKind::Token)),
-      TokKind(uint16_t(tok.getKind())),
+      TokKind(uint16_t(tokKind)),
       DK(DataKind::DeferredToken) {
-    assert(getTokenKind() == tok.getKind() && "Token kind is too large value!");
+    assert(getTokenKind() == tokKind && "Token kind is too large value!");
+    assert(DeferredToken.NumLeadingTrivia == numLeadingTrivia &&
+           "numLeadingTrivia is too large value!");
+    assert(DeferredToken.NumTrailingTrivia == numTrailingTrivia &&
+           "numLeadingTrivia is too large value!");
   }
 
 public:
@@ -106,63 +115,6 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
 
-  ParsedRawSyntaxNode(const ParsedRawSyntaxNode &other) {
-    switch (other.DK) {
-    case DataKind::Null:
-      break;
-    case DataKind::Recorded:
-      new(&this->RecordedData)RecordedSyntaxNode(other.RecordedData);
-      break;
-    case DataKind::DeferredLayout:
-      new(&this->DeferredLayout)DeferredLayoutNode(other.DeferredLayout);
-      break;
-    case DataKind::DeferredToken:
-      new(&this->DeferredToken)DeferredTokenNode(other.DeferredToken);
-      break;
-    }
-    this->SynKind = other.SynKind;
-    this->TokKind = other.TokKind;
-    this->DK = other.DK;
-  }
-
-  ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) {
-    switch (other.DK) {
-    case DataKind::Null:
-      break;
-    case DataKind::Recorded:
-      new(&this->RecordedData)RecordedSyntaxNode(
-          std::move(other.RecordedData));
-      break;
-    case DataKind::DeferredLayout:
-      new(&this->DeferredLayout)DeferredLayoutNode(
-          std::move(other.DeferredLayout));
-      break;
-    case DataKind::DeferredToken:
-      new(&this->DeferredToken)DeferredTokenNode(
-          std::move(other.DeferredToken));
-      break;
-    }
-    this->SynKind = other.SynKind;
-    this->TokKind = other.TokKind;
-    this->DK = other.DK;
-  }
-
-  ~ParsedRawSyntaxNode() {
-    releaseMemory();
-  }
-
-  ParsedRawSyntaxNode &operator=(const ParsedRawSyntaxNode &other) {
-    releaseMemory();
-    new (this)ParsedRawSyntaxNode(other);
-    return *this;
-  }
-
-  ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
-    releaseMemory();
-    new (this)ParsedRawSyntaxNode(std::move(other));
-    return *this;
-  }
-
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }
   tok getTokenKind() const { return tok(TokKind); }
 
@@ -201,44 +153,44 @@ class ParsedRawSyntaxNode {
     assert(DK == DataKind::DeferredLayout);
     return DeferredLayout.Children;
   }
-  void addDeferredChild(ParsedRawSyntaxNode subnode) {
-    assert(DK == DataKind::DeferredLayout);
-    DeferredLayout.Children.push_back(std::move(subnode));
-  }
 
   // Deferred Token Data =====================================================//
 
-  const Token &getToken() const {
+  CharSourceRange getDeferredTokenRangeWithoutBackticks() const {
     assert(DK == DataKind::DeferredToken);
-    return DeferredToken.Tok;
+    return CharSourceRange{DeferredToken.TokLoc, DeferredToken.TokLength};
   }
-  const ParsedTrivia &getLeadingTrivia() const {
+  ArrayRef<ParsedTriviaPiece> getDeferredLeadingTriviaPieces() const {
     assert(DK == DataKind::DeferredToken);
-    return DeferredToken.LeadingTrivia;
+    return ArrayRef<ParsedTriviaPiece>(DeferredToken.TriviaPieces,
+                                       DeferredToken.NumLeadingTrivia);
   }
-  const ParsedTrivia &getTrailingTrivia() const {
+  ArrayRef<ParsedTriviaPiece> getDeferredTrailingTriviaPieces() const {
     assert(DK == DataKind::DeferredToken);
-    return DeferredToken.TrailingTrivia;
+    return ArrayRef<ParsedTriviaPiece>(
+      DeferredToken.TriviaPieces + DeferredToken.NumLeadingTrivia,
+      DeferredToken.NumTrailingTrivia);
   }
 
   //==========================================================================//
 
   /// Form a deferred syntax layout node.
   static ParsedRawSyntaxNode makeDeferred(syntax::SyntaxKind k,
-                        ArrayRef<ParsedRawSyntaxNode> deferredNodes) {
-    return ParsedRawSyntaxNode{k, deferredNodes};
-  }
+                        ArrayRef<ParsedRawSyntaxNode> deferredNodes,
+                                          SyntaxParsingContext &ctx);
 
   /// Form a deferred token node.
   static ParsedRawSyntaxNode makeDeferred(Token tok,
-                                          ParsedTrivia leadingTrivia,
-                                          ParsedTrivia trailingTrivia) {
-    return ParsedRawSyntaxNode{std::move(tok), std::move(leadingTrivia),
-        std::move(trailingTrivia)};
-  }
+                                          const ParsedTrivia &leadingTrivia,
+                                          const ParsedTrivia &trailingTrivia,
+                                          SyntaxParsingContext &ctx);
 
   /// Form a deferred missing token node.
-  static ParsedRawSyntaxNode makeDeferredMissing(tok tokKind, SourceLoc loc);
+  static ParsedRawSyntaxNode makeDeferredMissing(tok tokKind, SourceLoc loc) {
+    auto raw = ParsedRawSyntaxNode(tokKind, loc, 0, nullptr, 0, 0);
+    raw.IsMissing = true;
+    return raw;
+  }
 
   /// Dump this piece of syntax recursively for debugging or testing.
   LLVM_ATTRIBUTE_DEPRECATED(
@@ -251,20 +203,6 @@ class ParsedRawSyntaxNode {
   static ParsedRawSyntaxNode null() {
     return ParsedRawSyntaxNode{};
   }
-
-private:
-  void releaseMemory() {
-    switch (DK) {
-    case DataKind::Null:
-      break;
-    case DataKind::Recorded:
-      RecordedData.~RecordedSyntaxNode(); break;
-    case DataKind::DeferredLayout:
-      DeferredLayout.~DeferredLayoutNode(); break;
-    case DataKind::DeferredToken:
-      DeferredToken.~DeferredTokenNode(); break;
-    }
-  }
 };
 
 } // end namespace swift

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -24,8 +24,10 @@
 
 namespace swift {
 
+class CharSourceRange;
 class ParsedRawSyntaxNode;
 struct ParsedTrivia;
+class ParsedTriviaPiece;
 class SyntaxParseActions;
 class SourceLoc;
 class Token;
@@ -46,6 +48,10 @@ class ParsedRawSyntaxRecorder {
                                   const ParsedTrivia &leadingTrivia,
                                   const ParsedTrivia &trailingTrivia);
 
+  ParsedRawSyntaxNode recordToken(tok tokenKind, CharSourceRange tokenRange,
+                                  ArrayRef<ParsedTriviaPiece> leadingTrivia,
+                                  ArrayRef<ParsedTriviaPiece> trailingTrivia);
+
   /// Record a missing token. \p loc can be invalid or an approximate location
   /// of where the token would be if not missing.
   ParsedRawSyntaxNode recordMissingToken(tok tokenKind, SourceLoc loc);

include/swift/Parse/ParsedSyntaxBuilders.h.gyb

@@ -34,17 +34,20 @@ class SyntaxParsingContext;
 %   if node.is_buildable():
 %     child_count = len(node.children)
 class Parsed${node.name}Builder {
-  ParsedRawSyntaxRecorder &Rec;
-  bool IsBacktracking;
-  ParsedRawSyntaxNode Layout[${child_count}] = {
+  SyntaxParsingContext &SPCtx;
+  ParsedRawSyntaxNode Layout[${child_count}];
 %     for child in node.children:
-    ParsedRawSyntaxNode::null(),
+%       child_node = NODE_MAP.get(child.syntax_kind)
+%       if child_node and child_node.is_syntax_collection():
+%         child_elt = child_node.collection_element_name
+%         child_elt_type = child_node.collection_element_type
+  SmallVector<ParsedRawSyntaxNode, 8> ${child_elt}Nodes;
+%       end
 %     end
-  };
 
 public:
   explicit Parsed${node.name}Builder(SyntaxParsingContext &SPCtx)
-    : Rec(SPCtx.getRecorder()), IsBacktracking(SPCtx.isBacktracking()) {}
+    : SPCtx(SPCtx) {}
 
 %     for child in node.children:
   Parsed${node.name}Builder &use${child.name}(Parsed${child.type_name} ${child.name});
@@ -61,7 +64,7 @@ public:
 
 private:
   Parsed${node.name} record();
-  void finishLayout();
+  void finishLayout(bool deferred);
 };
 
 %   end

include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -46,7 +46,8 @@ private:
   static Parsed${node.name} record${node.syntax_kind}(${child_params},
                                               ParsedRawSyntaxRecorder &rec);
 public:
-  static Parsed${node.name} defer${node.syntax_kind}(${child_params});
+  static Parsed${node.name} defer${node.syntax_kind}(${child_params},
+                                              SyntaxParsingContext &SPCtx);
   static Parsed${node.name} make${node.syntax_kind}(${child_params},
                                               SyntaxParsingContext &SPCtx);
 %   elif node.is_syntax_collection():
@@ -57,7 +58,8 @@ private:
 
 public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      ArrayRef<Parsed${node.collection_element_type}> elts);
+      ArrayRef<Parsed${node.collection_element_type}> elts,
+      SyntaxParsingContext &SPCtx);
   static Parsed${node.name} make${node.syntax_kind}(
       ArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);

include/swift/Parse/ParsedTrivia.h

@@ -14,6 +14,7 @@
 #define SWIFT_PARSE_PARSEDTRIVIA_H
 
 #include "swift/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace swift {
@@ -41,6 +42,17 @@ class ParsedTriviaPiece {
   void extendLength(unsigned len) {
     Length += len;
   }
+
+  static size_t getTotalLength(ArrayRef<ParsedTriviaPiece> pieces) {
+    size_t Len = 0;
+    for (auto &p : pieces)
+      Len += p.getLength();
+    return Len;
+  }
+
+  static syntax::Trivia
+  convertToSyntaxTrivia(ArrayRef<ParsedTriviaPiece> pieces, SourceLoc loc,
+                        const SourceManager &SM, unsigned bufferID);
 };
 
 using ParsedTriviaList = SmallVector<ParsedTriviaPiece, 3>;
@@ -68,11 +80,13 @@ struct ParsedTrivia {
     return Pieces.empty();
   }
 
+  /// Return the number of pieces in this Trivia collection.
+  size_t size() const {
+    return Pieces.size();
+  }
+
   size_t getLength() const {
-    size_t Len = 0;
-    for (auto &P : Pieces)
-      Len += P.getLength();
-    return Len;
+    return ParsedTriviaPiece::getTotalLength(Pieces);
   }
 
   void push_back(syntax::TriviaKind kind, unsigned length) {

include/swift/Parse/SyntaxParseActions.h

@@ -23,9 +23,8 @@
 namespace swift {
 
 class CharSourceRange;
-struct ParsedTrivia;
+class ParsedTriviaPiece;
 class SourceLoc;
-class Token;
 enum class tok;
 
 namespace syntax {
@@ -40,10 +39,10 @@ class SyntaxParseActions {
 public:
   virtual ~SyntaxParseActions() = default;
 
-  virtual OpaqueSyntaxNode recordToken(const Token &tok,
-                                       const ParsedTrivia &leadingTrivia,
-                                       const ParsedTrivia &trailingTrivia,
-                                       CharSourceRange range) = 0;
+  virtual OpaqueSyntaxNode recordToken(tok tokenKind,
+                                    ArrayRef<ParsedTriviaPiece> leadingTrivia,
+                                    ArrayRef<ParsedTriviaPiece> trailingTrivia,
+                                    CharSourceRange range) = 0;
 
   /// Record a missing token. \c loc can be invalid or an approximate location
   /// of where the token would be if not missing.

include/swift/Parse/SyntaxParsingContext.h

@@ -94,6 +94,8 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
 
     ParsedRawSyntaxRecorder Recorder;
 
+    llvm::BumpPtrAllocator ScratchAlloc;
+
     RootContextData(SourceFile &SF, DiagnosticEngine &Diags,
                     SourceManager &SourceMgr, unsigned BufferID,
                     std::shared_ptr<SyntaxParseActions> spActions)
@@ -242,12 +244,16 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
 
   ParsedRawSyntaxRecorder &getRecorder() { return getRootData()->Recorder; }
 
+  llvm::BumpPtrAllocator &getScratchAlloc() {
+    return getRootData()->ScratchAlloc;
+  }
+
   /// Add RawSyntax to the parts.
   void addRawSyntax(ParsedRawSyntaxNode Raw);
 
   /// Add Token with Trivia to the parts.
-  void addToken(Token &Tok, ParsedTrivia &LeadingTrivia,
-                ParsedTrivia &TrailingTrivia);
+  void addToken(Token &Tok, const ParsedTrivia &LeadingTrivia,
+                const ParsedTrivia &TrailingTrivia);
 
   /// Add Syntax to the parts.
   void addSyntax(ParsedSyntax Node);

include/swift/SyntaxParse/SyntaxTreeCreator.h

@@ -54,9 +54,9 @@ class SyntaxTreeCreator: public SyntaxParseActions {
   void acceptSyntaxRoot(OpaqueSyntaxNode root, SourceFile &SF);
 
 private:
-  OpaqueSyntaxNode recordToken(const Token &tok,
-                               const ParsedTrivia &leadingTrivia,
-                               const ParsedTrivia &trailingTrivia,
+  OpaqueSyntaxNode recordToken(tok tokenKind,
+                               ArrayRef<ParsedTriviaPiece> leadingTrivia,
+                               ArrayRef<ParsedTriviaPiece> trailingTrivia,
                                CharSourceRange range) override;
 
   OpaqueSyntaxNode recordMissingToken(tok tokenKind, SourceLoc loc) override;