[libSyntax] Eliminate loop and memory allocation translating ParsedRawSyntaxNode to RecordedOrDeferredNode

Author: ahoppen

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -173,7 +173,21 @@ class ParsedRawSyntaxRecorder final {
   ParsedRawSyntaxNode
   makeDeferred(syntax::SyntaxKind k,
                MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
-               SyntaxParsingContext &ctx);
+               SyntaxParsingContext &ctx) {
+#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
+    auto range = ParsedRawSyntaxRecorder::verifyElementRanges(deferredNodes);
+#endif
+
+    assert(llvm::none_of(deferredNodes, [](const ParsedRawSyntaxNode &node) {
+      return node.isRecorded();
+    }) && "Cannot create a deferred layout node that has recorded children");
+
+    auto data =
+        SPActions->makeDeferredLayout(k, /*IsMissing=*/false, deferredNodes);
+    return makeParsedRawSyntaxNode(
+        data, k, tok::NUM_TOKENS, ParsedRawSyntaxNode::DataKind::DeferredLayout,
+        /*IsMissing=*/false, range);
+  }
 
   /// Form a deferred token node.
   ParsedRawSyntaxNode makeDeferred(Token tok, StringRef leadingTrivia,

include/swift/Parse/SyntaxParseActions.h

@@ -28,6 +28,7 @@ class ParsedTriviaPiece;
 class SourceFile;
 class SourceLoc;
 enum class tok : uint8_t;
+class ParsedRawSyntaxNode;
 
 namespace syntax {
 class SourceFileSyntax;
@@ -113,9 +114,11 @@ class SyntaxParseActions {
   /// Create a deferred layout node that may or may not be recorded later using
   /// \c recordDeferredLayout. The \c SyntaxParseAction is responsible for
   /// keeping the deferred token alive until it is destructed.
+  /// From all nodes in \p children, the underlying opaque data will be *taken*
+  /// which resets the nodes.
   virtual OpaqueSyntaxNode
   makeDeferredLayout(syntax::SyntaxKind k, bool isMissing,
-                     const ArrayRef<RecordedOrDeferredNode> &children) = 0;
+                     const MutableArrayRef<ParsedRawSyntaxNode> &children) = 0;
 
   /// Record a deferred token node that was previously created using \c
   /// makeDeferredToken. The deferred data will never be used again, so it can

include/swift/SyntaxParse/SyntaxTreeCreator.h

@@ -76,9 +76,9 @@ class SyntaxTreeCreator final : public SyntaxParseActions {
                                      CharSourceRange range,
                                      bool isMissing) override;
 
-  OpaqueSyntaxNode
-  makeDeferredLayout(syntax::SyntaxKind k, bool IsMissing,
-                     const ArrayRef<RecordedOrDeferredNode> &children) override;
+  OpaqueSyntaxNode makeDeferredLayout(
+      syntax::SyntaxKind k, bool IsMissing,
+      const MutableArrayRef<ParsedRawSyntaxNode> &children) override;
 
   OpaqueSyntaxNode recordDeferredToken(OpaqueSyntaxNode deferred) override;
   OpaqueSyntaxNode recordDeferredLayout(OpaqueSyntaxNode deferred) override;

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -44,31 +44,6 @@ ParsedRawSyntaxRecorder::recordEmptyRawSyntaxCollection(SyntaxKind kind,
                                  /*IsMissing=*/false, CharSourceRange(loc, 0));
 }
 
-/// Create a deferred layout node.
-ParsedRawSyntaxNode ParsedRawSyntaxRecorder::makeDeferred(
-    syntax::SyntaxKind k, MutableArrayRef<ParsedRawSyntaxNode> deferredNodes,
-    SyntaxParsingContext &ctx) {
-#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
-  auto range = ParsedRawSyntaxRecorder::verifyElementRanges(deferredNodes);
-#endif
-
-  RecordedOrDeferredNode *newPtr =
-      ctx.getScratchAlloc().Allocate<RecordedOrDeferredNode>(
-          deferredNodes.size());
-  auto children = llvm::makeMutableArrayRef(newPtr, deferredNodes.size());
-  for (size_t i = 0; i < deferredNodes.size(); ++i) {
-    auto &node = deferredNodes[i];
-    assert(!node.isRecorded() &&
-           "Cannot create a deferred layout node that has recorded children");
-
-    children[i] = node.takeRecordedOrDeferredNode();
-  }
-  auto data = SPActions->makeDeferredLayout(k, /*IsMissing=*/false, children);
-  return makeParsedRawSyntaxNode(data, k, tok::NUM_TOKENS,
-                                 ParsedRawSyntaxNode::DataKind::DeferredLayout,
-                                 /*IsMissing=*/false, range);
-}
-
 ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::makeDeferredMissing(tok tokKind, SourceLoc loc) {
   auto Data = SPActions->makeDeferredToken(

lib/SyntaxParse/SyntaxTreeCreator.cpp

@@ -11,17 +11,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SyntaxParse/SyntaxTreeCreator.h"
-#include "swift/Syntax/RawSyntax.h"
-#include "swift/Syntax/SyntaxVisitor.h"
-#include "swift/Syntax/Trivia.h"
-#include "swift/Parse/ParsedTrivia.h"
-#include "swift/Parse/SyntaxParsingCache.h"
-#include "swift/Parse/Token.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/Basic/OwnedString.h"
+#include "swift/Parse/ParsedRawSyntaxNode.h"
+#include "swift/Parse/ParsedTrivia.h"
+#include "swift/Parse/SyntaxParsingCache.h"
+#include "swift/Parse/Token.h"
+#include "swift/Syntax/RawSyntax.h"
+#include "swift/Syntax/SyntaxVisitor.h"
+#include "swift/Syntax/Trivia.h"
 
 using namespace swift;
 using namespace swift::syntax;
@@ -188,12 +189,12 @@ OpaqueSyntaxNode SyntaxTreeCreator::makeDeferredToken(tok tokenKind,
 
 OpaqueSyntaxNode SyntaxTreeCreator::makeDeferredLayout(
     syntax::SyntaxKind k, bool IsMissing,
-    const ArrayRef<RecordedOrDeferredNode> &children) {
+    const MutableArrayRef<ParsedRawSyntaxNode> &children) {
   SmallVector<OpaqueSyntaxNode, 16> opaqueChildren;
   opaqueChildren.reserve(children.size());
 
   for (size_t i = 0; i < children.size(); ++i) {
-    opaqueChildren.push_back(children[i].getOpaque());
+    opaqueChildren.push_back(children[i].takeData());
   }
 
   // Also see comment in makeDeferredToken

tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp

@@ -245,12 +245,21 @@ class CLibParseActions final : public SyntaxParseActions {
 
   OpaqueSyntaxNode makeDeferredLayout(
       syntax::SyntaxKind k, bool isMissing,
-      const ArrayRef<RecordedOrDeferredNode> &children) override {
+      const MutableArrayRef<ParsedRawSyntaxNode> &parsedChildren) override {
     assert(!isMissing && "Missing layout nodes not implemented yet");
 
+    auto childrenMem = DeferredNodeAllocator.Allocate<RecordedOrDeferredNode>(
+        parsedChildren.size());
+    auto children =
+        llvm::makeMutableArrayRef(childrenMem, parsedChildren.size());
+
     // Compute the length of this node.
     unsigned length = 0;
-    for (auto &child : children) {
+    size_t index = 0;
+    for (auto &parsedChild : parsedChildren) {
+      auto child = parsedChild.takeRecordedOrDeferredNode();
+      children[index++] = child;
+
       switch (child.getKind()) {
       case RecordedOrDeferredNode::Kind::Null:
         break;