[libSyntax] Allow retrieval of a null child from deferred ParsedRawSyntaxNodes

Author: ahoppen

include/swift/Parse/SyntaxParseActions.h

@@ -67,13 +67,13 @@ class RecordedOrDeferredNode {
 /// \c getDeferredChild to maintain a clean dependency relationship of
 /// \c ParsedRawSyntaxNode being on a higher level than \c SyntaxParseActions.
 struct DeferredNodeInfo {
-  OpaqueSyntaxNode Data;
+  RecordedOrDeferredNode Data;
   syntax::SyntaxKind SyntaxKind;
   tok TokenKind;
   bool IsMissing;
   CharSourceRange Range;
 
-  DeferredNodeInfo(OpaqueSyntaxNode Data, syntax::SyntaxKind SyntaxKind,
+  DeferredNodeInfo(RecordedOrDeferredNode Data, syntax::SyntaxKind SyntaxKind,
                    tok TokenKind, bool IsMissing, CharSourceRange Range)
       : Data(Data), SyntaxKind(SyntaxKind), TokenKind(TokenKind),
         IsMissing(IsMissing), Range(Range) {}

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -214,14 +214,11 @@ ParsedRawSyntaxRecorder::getDeferredChild(const ParsedRawSyntaxNode &parent,
                                           size_t childIndex) const {
   assert(parent.isDeferredLayout());
   auto childInfo = SPActions->getDeferredChild(
-      parent.getUnsafeDeferredOpaqueData(),
-      childIndex, parent.getRange().getStart());
-  return ParsedRawSyntaxNode(childInfo.Data, childInfo.Range,
+      parent.getUnsafeDeferredOpaqueData(), childIndex,
+      parent.getRange().getStart());
+  return ParsedRawSyntaxNode(childInfo.Data.getOpaque(), childInfo.Range,
                              childInfo.SyntaxKind, childInfo.TokenKind,
-                             childInfo.SyntaxKind == syntax::SyntaxKind::Token
-                                 ? RecordedOrDeferredNode::Kind::DeferredToken
-                                 : RecordedOrDeferredNode::Kind::DeferredLayout,
-                             childInfo.IsMissing);
+                             childInfo.Data.getKind(), childInfo.IsMissing);
 }
 
 size_t ParsedRawSyntaxRecorder::getDeferredNumChildren(

lib/Parse/SyntaxParseActions.cpp

@@ -147,21 +147,28 @@ DeferredNodeInfo SyntaxParseActions::getDeferredChild(OpaqueSyntaxNode node,
   auto Child = Data->Children[ChildIndex];
   switch (Child.getKind()) {
   case RecordedOrDeferredNode::Kind::Null:
-    llvm_unreachable("A child node should not be Null");
+    return DeferredNodeInfo(
+        RecordedOrDeferredNode(nullptr, RecordedOrDeferredNode::Kind::Null),
+        syntax::SyntaxKind::Unknown, tok::NUM_TOKENS,
+        /*IsMissing=*/false, CharSourceRange());
   case RecordedOrDeferredNode::Kind::Recorded:
     llvm_unreachable("Children of deferred nodes must also be deferred");
     break;
   case RecordedOrDeferredNode::Kind::DeferredLayout: {
     auto ChildData = static_cast<const DeferredLayoutNode *>(Child.getOpaque());
-    return DeferredNodeInfo(ChildData, ChildData->Kind, tok::NUM_TOKENS,
-                            /*IsMissing=*/false,
-                            CharSourceRange(StartLoc, ChildData->Length));
+    return DeferredNodeInfo(
+        RecordedOrDeferredNode(ChildData,
+                               RecordedOrDeferredNode::Kind::DeferredLayout),
+        ChildData->Kind, tok::NUM_TOKENS,
+        /*IsMissing=*/false, CharSourceRange(StartLoc, ChildData->Length));
   }
   case RecordedOrDeferredNode::Kind::DeferredToken: {
     auto ChildData = static_cast<const DeferredTokenNode *>(Child.getOpaque());
-    return DeferredNodeInfo(ChildData, syntax::SyntaxKind::Token,
-                            ChildData->TokenKind, ChildData->IsMissing,
-                            ChildData->Range);
+    return DeferredNodeInfo(
+        RecordedOrDeferredNode(ChildData,
+                               RecordedOrDeferredNode::Kind::DeferredToken),
+        syntax::SyntaxKind::Token, ChildData->TokenKind, ChildData->IsMissing,
+        ChildData->Range);
   }
   }
 }