[libSyntax] Re-enable dumping of ParsedRawSyntaxNode children

This requires a SyntaxParsingContext to be passed to the dump function
and was thus disabled in an earlier commit

Author: ahoppen

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -187,6 +187,9 @@ class ParsedRawSyntaxNode {
   getDeferredChild(size_t ChildIndex,
                    const SyntaxParsingContext *SyntaxContext) const;
 
+  size_t
+  getDeferredNumChildren(const SyntaxParsingContext *SyntaxContext) const;
+
   ParsedRawSyntaxNode copyDeferred() const {
     assert(isDeferredLayout() || isDeferredToken() && "node not deferred");
     ParsedRawSyntaxNode copy;
@@ -203,8 +206,10 @@ class ParsedRawSyntaxNode {
   /// Dump this piece of syntax recursively for debugging or testing.
   SWIFT_DEBUG_DUMP;
 
-  /// Dump this piece of syntax recursively.
-  void dump(raw_ostream &OS, unsigned Indent = 0) const;
+  /// Dump this piece of syntax recursively. If \p Context is passed, this
+  /// method is also able to traverse its children and dump them.
+  void dump(raw_ostream &OS, const SyntaxParsingContext *Context = nullptr,
+            unsigned Indent = 0) const;
 
   static ParsedRawSyntaxNode null() {
     return ParsedRawSyntaxNode{};

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -98,6 +98,9 @@ class ParsedRawSyntaxRecorder final {
   ParsedRawSyntaxNode getDeferredChild(const ParsedRawSyntaxNode &parent,
                                        size_t ChildIndex) const;
 
+  /// For a deferred layout node \p node, retrieve the number of children.
+  size_t getDeferredNumChildren(const ParsedRawSyntaxNode &node) const;
+
 #ifndef NDEBUG
   static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
 #endif

include/swift/Parse/SyntaxParseActions.h

@@ -142,6 +142,10 @@ class SyntaxParseActions {
                                             size_t childIndex,
                                             SourceLoc startLoc);
 
+  /// Return the number of children, \p node has. These can be retrieved using
+  /// \c getDeferredChild.
+  virtual size_t getDeferredNumChildren(OpaqueSyntaxNode node);
+
   /// Attempt to realize an opaque raw syntax node for a source file into a
   /// SourceFileSyntax node. This will return \c None if the parsing action
   /// doesn't support the realization of syntax nodes.

lib/Parse/ParsedRawSyntaxNode.cpp

@@ -23,12 +23,20 @@ ParsedRawSyntaxNode ParsedRawSyntaxNode::getDeferredChild(
   return SyntaxContext->getRecorder().getDeferredChild(*this, ChildIndex);
 }
 
+size_t ParsedRawSyntaxNode::getDeferredNumChildren(
+    const SyntaxParsingContext *SyntaxContext) const {
+  assert(isDeferredLayout());
+  return SyntaxContext->getRecorder().getDeferredNumChildren(*this);
+}
+
 void ParsedRawSyntaxNode::dump() const {
   dump(llvm::errs(), /*Indent*/ 0);
   llvm::errs() << '\n';
 }
 
-void ParsedRawSyntaxNode::dump(llvm::raw_ostream &OS, unsigned Indent) const {
+void ParsedRawSyntaxNode::dump(llvm::raw_ostream &OS,
+                               const SyntaxParsingContext *Context,
+                               unsigned Indent) const {
   for (decltype(Indent) i = 0; i < Indent; ++i)
     OS << ' ';
   OS << '(';
@@ -48,7 +56,17 @@ void ParsedRawSyntaxNode::dump(llvm::raw_ostream &OS, unsigned Indent) const {
       break;
     case DataKind::DeferredLayout:
       dumpSyntaxKind(OS, getKind());
-      OS << " [deferred layout]";
+      OS << " [deferred]";
+      if (Context) {
+        size_t numChildren = getDeferredNumChildren(Context);
+        for (size_t i = 0; i < numChildren; ++i) {
+          auto child = getDeferredChild(i, Context);
+          OS << "\n";
+          child.dump(OS, Context, Indent + 2);
+        }
+      } else {
+        OS << " (unknown children)";
+      }
       break;
     case DataKind::DeferredToken:
       dumpSyntaxKind(OS, getKind());

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -223,6 +223,12 @@ ParsedRawSyntaxRecorder::getDeferredChild(const ParsedRawSyntaxNode &parent,
                              childInfo.IsMissing);
 }
 
+size_t ParsedRawSyntaxRecorder::getDeferredNumChildren(
+    const ParsedRawSyntaxNode &node) const {
+  assert(node.isDeferredLayout());
+  return SPActions->getDeferredNumChildren(node.getData());
+}
+
 #ifndef NDEBUG
 void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
   SourceLoc prevEndLoc;

lib/Parse/SyntaxParseActions.cpp

@@ -165,3 +165,8 @@ DeferredNodeInfo SyntaxParseActions::getDeferredChild(OpaqueSyntaxNode node,
   }
   }
 }
+
+size_t SyntaxParseActions::getDeferredNumChildren(OpaqueSyntaxNode node) {
+  auto Data = static_cast<const DeferredLayoutNode *>(node);
+  return Data->Children.size();
+}