Merge pull request swiftlang#36417 from ahoppen/pr/libsyntax-performance-improvements

ahoppen · web-flow · commit fece895cb914 · 2021-03-16T23:53:22.000+01:00
[libSyntax] Several small improvements to libSyntax parsing
diff --git a/include/swift/Parse/ParsedRawSyntaxRecorder.h b/include/swift/Parse/ParsedRawSyntaxRecorder.h
@@ -21,8 +21,24 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Parse/ParsedRawSyntaxNode.h"
+#include "swift/Parse/SyntaxParseActions.h"
+#include "swift/SyntaxParse/SyntaxTreeCreator.h"
 #include <memory>
 
+/// Define a macro that creates a \c ParsedRawSyntaxNode. If \c
+/// PARSEDRAWSYNTAXNODE_VERIFY_RANGES is defined, it passes the \c Range
+/// parameter, otherwise it ignores it at the pre-processor level, which means
+/// that \c Range can be an invalid expression.
+#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
+#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
+                                Range)                                         \
+  ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, Range)
+#else
+#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
+                                Range)                                         \
+  ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing)
+#endif
+
 namespace swift {
 
 class CharSourceRange;
@@ -57,18 +73,50 @@ class ParsedRawSyntaxRecorder final {
   /// return the recorded node.
   /// This consumes the data from \c node, which is unusable after it has been
   /// recorded. The returned node should be used afterwards instead.
-  ParsedRawSyntaxNode recordDeferredNode(ParsedRawSyntaxNode &node);
+  ParsedRawSyntaxNode recordDeferredNode(ParsedRawSyntaxNode &node) {
+    switch (node.getDataKind()) {
+    case RecordedOrDeferredNode::Kind::Null:
+    case RecordedOrDeferredNode::Kind::Recorded:
+      llvm_unreachable("Not deferred");
+    case RecordedOrDeferredNode::Kind::DeferredLayout: {
+      OpaqueSyntaxNode Data = SPActions->recordDeferredLayout(node.takeData());
+      return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
+                                     ParsedRawSyntaxNode::DataKind::Recorded,
+                                     node.isMissing(), node.getRange());
+    }
+    case RecordedOrDeferredNode::Kind::DeferredToken: {
+      OpaqueSyntaxNode Data = SPActions->recordDeferredToken(node.takeData());
+      return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
+                                     ParsedRawSyntaxNode::DataKind::Recorded,
+                                     node.isMissing(), node.getRange());
+    }
+    }
+  }
 
 public:
   explicit ParsedRawSyntaxRecorder(std::shared_ptr<SyntaxParseActions> spActions)
     : SPActions(std::move(spActions)) {}
 
   ParsedRawSyntaxNode recordToken(const Token &tok, StringRef leadingTrivia,
-                                  StringRef trailingTrivia);
+                                  StringRef trailingTrivia) {
+    return recordToken(tok.getKind(), tok.getRange(), leadingTrivia,
+                       trailingTrivia);
+  }
 
   ParsedRawSyntaxNode recordToken(tok tokenKind, CharSourceRange tokenRange,
                                   StringRef leadingTrivia,
-                                  StringRef trailingTrivia);
+                                  StringRef trailingTrivia) {
+    SourceLoc offset =
+        tokenRange.getStart().getAdvancedLoc(-leadingTrivia.size());
+    unsigned length = leadingTrivia.size() + tokenRange.getByteLength() +
+                      trailingTrivia.size();
+    CharSourceRange range(offset, length);
+    OpaqueSyntaxNode n =
+        SPActions->recordToken(tokenKind, leadingTrivia, trailingTrivia, range);
+    return makeParsedRawSyntaxNode(n, syntax::SyntaxKind::Token, tokenKind,
+                                   ParsedRawSyntaxNode::DataKind::Recorded,
+                                   /*IsMissing=*/false, range);
+  }
 
   /// Record a missing token. \p loc can be invalid or an approximate location
   /// of where the token would be if not missing.
@@ -77,8 +125,39 @@ class ParsedRawSyntaxRecorder final {
   /// The provided \p elements are an exact layout appropriate for the syntax
   /// \p kind. Missing optional elements are represented with a null
   /// ParsedRawSyntaxNode object.
-  ParsedRawSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
-                                      MutableArrayRef<ParsedRawSyntaxNode> elements);
+  ParsedRawSyntaxNode
+  recordRawSyntax(syntax::SyntaxKind kind,
+                  MutableArrayRef<ParsedRawSyntaxNode> elements) {
+    assert(kind != syntax::SyntaxKind::Token &&
+           "Use recordToken to record a token");
+#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
+    auto range = ParsedRawSyntaxRecorder::verifyElementRanges(elements);
+#endif
+
+    SmallVector<OpaqueSyntaxNode, 16> subnodes;
+    if (!elements.empty()) {
+      for (auto &subnode : elements) {
+        switch (subnode.getDataKind()) {
+        case RecordedOrDeferredNode::Kind::Null:
+          subnodes.push_back(nullptr);
+          break;
+        case RecordedOrDeferredNode::Kind::Recorded:
+          subnodes.push_back(subnode.takeData());
+          break;
+        case RecordedOrDeferredNode::Kind::DeferredLayout:
+        case RecordedOrDeferredNode::Kind::DeferredToken: {
+          auto recorded = recordDeferredNode(subnode);
+          subnodes.push_back(recorded.takeData());
+          break;
+        }
+        }
+      }
+    }
+    OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, subnodes);
+    return makeParsedRawSyntaxNode(n, kind, tok::NUM_TOKENS,
+                                   ParsedRawSyntaxNode::DataKind::Recorded,
+                                   /*IsMissing=*/false, range);
+  }
 
   /// Record a raw syntax collecton without eny elements. \p loc can be invalid
   /// or an approximate location of where an element of the collection would be
@@ -94,11 +173,38 @@ 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,
-                                   StringRef trailingTrivia);
+                                   StringRef trailingTrivia) {
+    CharSourceRange tokRange = tok.getRange();
+    CharSourceRange RangeWithTrivia = CharSourceRange(
+        tokRange.getStart().getAdvancedLoc(-leadingTrivia.size()),
+        (unsigned)leadingTrivia.size() + tokRange.getByteLength() +
+            (unsigned)trailingTrivia.size());
+    auto Data = SPActions->makeDeferredToken(tok.getKind(), leadingTrivia,
+                                             trailingTrivia, RangeWithTrivia,
+                                             /*IsMissing=*/false);
+    return makeParsedRawSyntaxNode(Data, syntax::SyntaxKind::Token,
+                                   tok.getKind(),
+                                   ParsedRawSyntaxNode::DataKind::DeferredToken,
+                                   /*IsMissing=*/false, RangeWithTrivia);
+  }
 
   /// Form a deferred missing token node.
   ParsedRawSyntaxNode makeDeferredMissing(tok tokKind, SourceLoc loc);
diff --git a/include/swift/Parse/SyntaxParseActions.h b/include/swift/Parse/SyntaxParseActions.h
@@ -30,6 +30,7 @@ class ParsedTriviaPiece;
 class SourceFile;
 class SourceLoc;
 enum class tok : uint8_t;
+class ParsedRawSyntaxNode;
 
 namespace syntax {
 class SourceFileSyntax;
@@ -112,9 +113,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
diff --git a/include/swift/SyntaxParse/SyntaxTreeCreator.h b/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;
diff --git a/lib/Parse/ParsedRawSyntaxRecorder.cpp b/lib/Parse/ParsedRawSyntaxRecorder.cpp
@@ -27,63 +27,6 @@
 using namespace swift;
 using namespace swift::syntax;
 
-/// Define a macro that creates a \c ParsedRawSyntaxNode. If \c
-/// PARSEDRAWSYNTAXNODE_VERIFY_RANGES is defined, it passes the \c Range
-/// parameter, otherwise it ignores it at the pre-processor level, which means
-/// that \c Range can be an invalid expression.
-#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
-#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
-                                Range)                                         \
-  ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, Range)
-#else
-#define makeParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing, \
-                                Range)                                         \
-  ParsedRawSyntaxNode(Opaque, SynKind, TokKind, DataKind, IsMissing)
-#endif
-
-ParsedRawSyntaxNode
-ParsedRawSyntaxRecorder::recordDeferredNode(ParsedRawSyntaxNode &node) {
-  switch (node.getDataKind()) {
-  case RecordedOrDeferredNode::Kind::Null:
-  case RecordedOrDeferredNode::Kind::Recorded:
-    llvm_unreachable("Not deferred");
-  case RecordedOrDeferredNode::Kind::DeferredLayout: {
-    OpaqueSyntaxNode Data = SPActions->recordDeferredLayout(node.takeData());
-    return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
-                                   ParsedRawSyntaxNode::DataKind::Recorded,
-                                   node.isMissing(), node.getRange());
-  }
-  case RecordedOrDeferredNode::Kind::DeferredToken: {
-    OpaqueSyntaxNode Data = SPActions->recordDeferredToken(node.takeData());
-    return makeParsedRawSyntaxNode(Data, node.getKind(), node.getTokenKind(),
-                                   ParsedRawSyntaxNode::DataKind::Recorded,
-                                   node.isMissing(), node.getRange());
-  }
-  }
-}
-
-ParsedRawSyntaxNode
-ParsedRawSyntaxRecorder::recordToken(const Token &tok, StringRef leadingTrivia,
-                                     StringRef trailingTrivia) {
-  return recordToken(tok.getKind(), tok.getRange(), leadingTrivia,
-                     trailingTrivia);
-}
-
-ParsedRawSyntaxNode
-ParsedRawSyntaxRecorder::recordToken(tok tokKind, CharSourceRange tokRange,
-                                     StringRef leadingTrivia,
-                                     StringRef trailingTrivia) {
-  SourceLoc offset = tokRange.getStart().getAdvancedLoc(-leadingTrivia.size());
-  unsigned length =
-      leadingTrivia.size() + tokRange.getByteLength() + trailingTrivia.size();
-  CharSourceRange range(offset, length);
-  OpaqueSyntaxNode n =
-      SPActions->recordToken(tokKind, leadingTrivia, trailingTrivia, range);
-  return makeParsedRawSyntaxNode(n, SyntaxKind::Token, tokKind,
-                                 ParsedRawSyntaxNode::DataKind::Recorded,
-                                 /*IsMissing=*/false, range);
-}
-
 ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
   OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
@@ -92,39 +35,6 @@ ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
                                  /*isMissing=*/true, CharSourceRange(loc, 0));
 }
 
-ParsedRawSyntaxNode
-ParsedRawSyntaxRecorder::recordRawSyntax(SyntaxKind kind,
-                                         MutableArrayRef<ParsedRawSyntaxNode> elements) {
-  assert(kind != SyntaxKind::Token && "Use recordToken to record a token");
-#ifdef PARSEDRAWSYNTAXNODE_VERIFY_RANGES
-  auto range = ParsedRawSyntaxRecorder::verifyElementRanges(elements);
-#endif
-
-  SmallVector<OpaqueSyntaxNode, 16> subnodes;
-  if (!elements.empty()) {
-    for (auto &subnode : elements) {
-      switch (subnode.getDataKind()) {
-      case RecordedOrDeferredNode::Kind::Null:
-        subnodes.push_back(nullptr);
-        break;
-      case RecordedOrDeferredNode::Kind::Recorded:
-        subnodes.push_back(subnode.takeData());
-        break;
-      case RecordedOrDeferredNode::Kind::DeferredLayout:
-      case RecordedOrDeferredNode::Kind::DeferredToken: {
-        auto recorded = recordDeferredNode(subnode);
-        subnodes.push_back(recorded.takeData());
-        break;
-      }
-      }
-    }
-  }
-  OpaqueSyntaxNode n = SPActions->recordRawSyntax(kind, subnodes);
-  return makeParsedRawSyntaxNode(n, kind, tok::NUM_TOKENS,
-                                 ParsedRawSyntaxNode::DataKind::Recorded,
-                                 /*IsMissing=*/false, range);
-}
-
 ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::recordEmptyRawSyntaxCollection(SyntaxKind kind,
                                                         SourceLoc loc) {
@@ -134,48 +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);
-}
-
-/// Create a deferred token node.
-ParsedRawSyntaxNode
-ParsedRawSyntaxRecorder::makeDeferred(Token tok, StringRef leadingTrivia,
-                                      StringRef trailingTrivia) {
-  CharSourceRange tokRange = tok.getRange();
-  CharSourceRange RangeWithTrivia = CharSourceRange(
-      tokRange.getStart().getAdvancedLoc(-leadingTrivia.size()),
-      (unsigned)leadingTrivia.size() + tokRange.getByteLength() +
-          (unsigned)trailingTrivia.size());
-  auto Data =
-      SPActions->makeDeferredToken(tok.getKind(), leadingTrivia, trailingTrivia,
-                                   RangeWithTrivia, /*IsMissing=*/false);
-  return makeParsedRawSyntaxNode(Data, SyntaxKind::Token, tok.getKind(),
-                                 ParsedRawSyntaxNode::DataKind::DeferredToken,
-                                 /*IsMissing=*/false, RangeWithTrivia);
-}
-
 ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::makeDeferredMissing(tok tokKind, SourceLoc loc) {
   auto Data = SPActions->makeDeferredToken(
diff --git a/lib/SyntaxParse/SyntaxTreeCreator.cpp b/lib/SyntaxParse/SyntaxTreeCreator.cpp
diff --git a/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp b/tools/libSwiftSyntaxParser/libSwiftSyntaxParser.cpp
