Merge pull request #36362 from ahoppen/pr/parsedrawsyntax-cleanup

[libSyntax] Minor cleanup in ParsedRawSyntaxNode

Author: ahoppen

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -59,6 +59,8 @@ class ParsedRawSyntaxNode {
   ParsedRawSyntaxNode &operator=(const ParsedRawSyntaxNode &other) = delete;
 
 public:
+  // MARK: - Constructors
+
   ParsedRawSyntaxNode()
       : Data(nullptr, DataKind::Null), Range(),
         SynKind(uint16_t(syntax::SyntaxKind::Unknown)),
@@ -73,17 +75,6 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == TokKind && "Token kind with too large value!");
   }
 
-#ifndef NDEBUG
-  bool ensureDataIsNotRecorded() {
-    if (getDataKind() != DataKind::Recorded)
-      return true;
-    llvm::dbgs() << "Leaking node: ";
-    dump(llvm::dbgs());
-    llvm::dbgs() << "\n";
-    return false;
-  }
-#endif
-
   ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
     assert(ensureDataIsNotRecorded() &&
            "recorded data is being destroyed by assignment");
@@ -95,17 +86,36 @@ class ParsedRawSyntaxNode {
     other.reset();
     return *this;
   }
+
   ParsedRawSyntaxNode(ParsedRawSyntaxNode &&other) : ParsedRawSyntaxNode() {
     *this = std::move(other);
   }
+
+  static ParsedRawSyntaxNode null() {
+    return ParsedRawSyntaxNode{};
+  }
+
   ~ParsedRawSyntaxNode() {
     assert(ensureDataIsNotRecorded() && "recorded data is being destructed");
   }
 
+  // MARK: - Retrieving node kind
+
   /// Returns the type of this node (recorded, deferred layout, deferred token,
   /// null).
   DataKind getDataKind() const { return Data.getKind(); }
 
+  bool isNull() const { return getDataKind() == DataKind::Null; }
+  bool isRecorded() const { return getDataKind() == DataKind::Recorded; }
+  bool isDeferredLayout() const {
+    return getDataKind() == DataKind::DeferredLayout;
+  }
+  bool isDeferredToken() const {
+    return getDataKind() == DataKind::DeferredToken;
+  }
+
+  // MARK: - Retrieving opaque data
+
   /// Returns the opaque data of this node, assuming that it is deferred. This
   /// must be interpreted by the \c SyntaxParseAction, which likely also needs
   /// the node type (layout or token) to interpret the data.
@@ -116,19 +126,21 @@ class ParsedRawSyntaxNode {
     return Data.getOpaque();
   }
 
-  RecordedOrDeferredNode takeRecordedOrDeferredNode() {
-    RecordedOrDeferredNode Data = this->Data;
+  /// Return the opaque data of this node and reset it.
+  OpaqueSyntaxNode takeData() {
+    OpaqueSyntaxNode Data = this->Data.getOpaque();
     reset();
     return Data;
   }
 
-  /// Return the opaque data of this node and reset it.
-  OpaqueSyntaxNode takeData() {
-    OpaqueSyntaxNode Data = this->Data.getOpaque();
+  RecordedOrDeferredNode takeRecordedOrDeferredNode() {
+    RecordedOrDeferredNode Data = this->Data;
     reset();
     return Data;
   }
 
+  // MARK: - Retrieving additional node info
+
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }
   tok getTokenKind() const { return tok(TokKind); }
 
@@ -138,41 +150,13 @@ class ParsedRawSyntaxNode {
   bool isToken(tok tokKind) const {
     return getTokenKind() == tokKind;
   }
-
-  bool isNull() const { return getDataKind() == DataKind::Null; }
-
-  bool isRecorded() const { return getDataKind() == DataKind::Recorded; }
-  bool isDeferredLayout() const {
-    return getDataKind() == DataKind::DeferredLayout;
-  }
-  bool isDeferredToken() const {
-    return getDataKind() == DataKind::DeferredToken;
-  }
-
-  /// Primary used for a deferred missing token.
   bool isMissing() const { return IsMissing; }
 
-  void reset() {
-    Data = RecordedOrDeferredNode(nullptr, DataKind::Null);
-    SynKind = uint16_t(syntax::SyntaxKind::Unknown);
-    TokKind = uint16_t(tok::unknown);
-    IsMissing = false;
-  }
-
-  ParsedRawSyntaxNode unsafeCopy() const {
-    ParsedRawSyntaxNode copy;
-    copy.Data = Data;
-    copy.Range = Range;
-    copy.SynKind = SynKind;
-    copy.TokKind = TokKind;
-    copy.IsMissing = IsMissing;
-    return copy;
-  }
-
   /// Returns the range of this node including leading and trailing trivia.
   CharSourceRange getRange() const { return Range; }
 
-  // Deferred Layout Data ====================================================//
+  size_t
+  getDeferredNumChildren(const SyntaxParsingContext *SyntaxContext) const;
 
   /// If this node is a deferred layout node, return the child at index \p
   /// ChildIndex.
@@ -183,11 +167,17 @@ class ParsedRawSyntaxNode {
   getDeferredChild(size_t ChildIndex,
                    const SyntaxParsingContext *SyntaxContext) const;
 
-  size_t
-  getDeferredNumChildren(const SyntaxParsingContext *SyntaxContext) const;
+  // MARK: - Miscellaneous
 
-  ParsedRawSyntaxNode copyDeferred() const {
-    assert(isDeferredLayout() || isDeferredToken() && "node not deferred");
+  void reset() {
+    Data = RecordedOrDeferredNode(nullptr, DataKind::Null);
+    SynKind = uint16_t(syntax::SyntaxKind::Unknown);
+    TokKind = uint16_t(tok::unknown);
+    IsMissing = false;
+    Range = CharSourceRange();
+  }
+
+  ParsedRawSyntaxNode unsafeCopy() const {
     ParsedRawSyntaxNode copy;
     copy.Data = Data;
     copy.Range = Range;
@@ -197,7 +187,18 @@ class ParsedRawSyntaxNode {
     return copy;
   }
 
-  //==========================================================================//
+#ifndef NDEBUG
+  bool ensureDataIsNotRecorded() {
+    if (getDataKind() != DataKind::Recorded)
+      return true;
+    llvm::dbgs() << "Leaking node: ";
+    dump(llvm::dbgs());
+    llvm::dbgs() << "\n";
+    return false;
+  }
+#endif
+
+  // MARK: - Printing
 
   /// Dump this piece of syntax recursively for debugging or testing.
   SWIFT_DEBUG_DUMP;
@@ -206,10 +207,6 @@ class ParsedRawSyntaxNode {
   /// 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{};
-  }
 };
 
 } // end namespace swift

include/swift/Parse/ParsedSyntax.h

@@ -43,10 +43,6 @@ class ParsedSyntax {
     return T(std::move(RawNode));
   }
 
-  ParsedSyntax copyDeferred() const {
-    return ParsedSyntax { RawNode.copyDeferred() };
-  }
-
   static bool kindof(syntax::SyntaxKind Kind) {
     return true;
   }

lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -231,7 +231,7 @@ size_t ParsedRawSyntaxRecorder::getDeferredNumChildren(
 void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
   SourceLoc prevEndLoc;
   for (const auto &elem: elements) {
-    if (elem.isMissing() || elem.isNull())
+    if (elem.isNull() || elem.isMissing())
       continue;
     CharSourceRange range = elem.getRange();
     if (range.isValid()) {

lib/Parse/ParsedSyntaxNodes.cpp.gyb

@@ -31,11 +31,11 @@ Parsed${node.name}::getDeferred${child.name}(const SyntaxParsingContext *SyntaxC
   auto RawChild = getRaw().getDeferredChild(${node.name}::Cursor::${child.name}, SyntaxContext);
   if (RawChild.isNull())
     return None;
-  return Parsed${child.type_name} {RawChild.copyDeferred()};
+  return Parsed${child.type_name}(std::move(RawChild));
 }
 %     else:
 Parsed${child.type_name} Parsed${node.name}::getDeferred${child.name}(const SyntaxParsingContext *SyntaxContext) {
-  return Parsed${child.type_name} {getRaw().getDeferredChild(${node.name}::Cursor::${child.name}, SyntaxContext).copyDeferred()};
+  return Parsed${child.type_name} {getRaw().getDeferredChild(${node.name}::Cursor::${child.name}, SyntaxContext)};
 }
 %     end