[ParsedRawSyntaxNode] Explicitely specify if a ParsedRawSyntaxNode is null using a DataKind

Avoid implicitely assuming 'null' node if its OpaqueSyntaxNode is null, there should be no interpretation
of OpaqueSyntaxNode values, a SyntaxParseActions implementation should be able to return null pointers as OpaqueSyntaxNode.

Author: akyrtzi

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -39,6 +39,7 @@ typedef void *OpaqueSyntaxNode;
 /// in the current parsing context.
 class ParsedRawSyntaxNode {
   enum class DataKind: uint8_t {
+    Null,
     Recorded,
     DeferredLayout,
     DeferredToken,
@@ -90,8 +91,11 @@ class ParsedRawSyntaxNode {
 
 public:
   ParsedRawSyntaxNode()
-    : ParsedRawSyntaxNode(syntax::SyntaxKind::Unknown, tok::unknown,
-                          {}, nullptr) {}
+    : RecordedData{},
+      SynKind(uint16_t(syntax::SyntaxKind::Unknown)),
+      TokKind(uint16_t(tok::unknown)),
+      DK(DataKind::Null) {
+  }
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
                       CharSourceRange r, OpaqueSyntaxNode n)
@@ -104,6 +108,8 @@ class ParsedRawSyntaxNode {
 
   ParsedRawSyntaxNode(const ParsedRawSyntaxNode &other) {
     switch (other.DK) {
+    case DataKind::Null:
+      break;
     case DataKind::Recorded:
       new(&this->RecordedData)RecordedSyntaxNode(other.RecordedData);
       break;
@@ -121,6 +127,8 @@ class ParsedRawSyntaxNode {
 
   ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) {
     switch (other.DK) {
+    case DataKind::Null:
+      break;
     case DataKind::Recorded:
       new(&this->RecordedData)RecordedSyntaxNode(
           std::move(other.RecordedData));
@@ -166,7 +174,7 @@ class ParsedRawSyntaxNode {
   }
 
   bool isNull() const {
-    return isRecorded() && RecordedData.OpaqueNode == nullptr;
+    return DK == DataKind::Null;
   }
 
   bool isRecorded() const { return DK == DataKind::Recorded; }
@@ -247,6 +255,8 @@ class ParsedRawSyntaxNode {
 private:
   void releaseMemory() {
     switch (DK) {
+    case DataKind::Null:
+      break;
     case DataKind::Recorded:
       RecordedData.~RecordedSyntaxNode(); break;
     case DataKind::DeferredLayout:

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -56,7 +56,7 @@ ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
 
 static ParsedRawSyntaxNode
 getRecordedNode(const ParsedRawSyntaxNode &node, ParsedRawSyntaxRecorder &rec) {
-  if (node.isRecorded())
+  if (node.isNull() || node.isRecorded())
     return node;
   if (node.isDeferredLayout())
     return rec.recordRawSyntax(node.getKind(), node.getDeferredChildren());
@@ -78,8 +78,10 @@ ParsedRawSyntaxRecorder::recordRawSyntax(SyntaxKind kind,
     unsigned length = 0;
     for (const auto &elem : elements) {
       auto subnode = getRecordedNode(elem, *this);
-      subnodes.push_back(subnode.getOpaqueNode());
-      if (!subnode.isNull()) {
+      if (subnode.isNull()) {
+        subnodes.push_back(nullptr);
+      } else {
+        subnodes.push_back(subnode.getOpaqueNode());
         auto range = subnode.getRange();
         if (range.isValid()) {
           if (offset.isInvalid())
@@ -108,6 +110,9 @@ ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
   size_t length;
   OpaqueSyntaxNode n;
   std::tie(length, n) = SPActions->lookupNode(lexerOffset, kind);
+  if (length == 0) {
+    return ParsedRawSyntaxNode::null();
+  }
   CharSourceRange range{loc, unsigned(length)};
   return ParsedRawSyntaxNode{kind, tok::unknown, range, n};
 }

lib/Parse/Parser.cpp

@@ -1123,6 +1123,9 @@ OpaqueSyntaxNode ParserUnit::parse() {
     Done = P.Tok.is(tok::eof);
   }
   auto rawNode = P.finalizeSyntaxTree();
+  if (rawNode.isNull()) {
+    return nullptr;
+  }
   return rawNode.getOpaqueNode();
 }