[libSyntax] Add getChild accessors for SyntaxDataRef

Author: ahoppen

include/swift/Syntax/SyntaxData.h

@@ -89,9 +89,6 @@ class SyntaxDataRef {
   /// and released when \c this is destroyed.
   const SyntaxDataRef *Parent;
 
-  /// Creates an *uninitialized* \c SyntaxDataRef.
-  SyntaxDataRef() {}
-
   /// Creates a \c SyntaxDataRef. \p AbsoluteRaw must not be null. If \p Parent
   /// is a \c nullptr, this node represents the root of a tree.
   SyntaxDataRef(const AbsoluteRawSyntax &AbsoluteRaw,
@@ -101,16 +98,22 @@ class SyntaxDataRef {
 
 #ifndef NDEBUG
   virtual bool isRef() const { return true; }
-  virtual ~SyntaxDataRef() {}
 #endif
 
 public:
+  /// Creates an *uninitialized* \c SyntaxDataRef.
+  SyntaxDataRef() {}
+
   SyntaxDataRef(const SyntaxDataRef &DataRef) = default;
   SyntaxDataRef(SyntaxDataRef &&DataRef) = default;
 
   SyntaxDataRef &operator=(SyntaxDataRef const &other) = default;
   SyntaxDataRef &operator=(SyntaxDataRef &&other) = default;
 
+#ifndef NDEBUG
+  virtual ~SyntaxDataRef() {}
+#endif
+
   // MARK: - Retrieving underlying data
 
   const AbsoluteRawSyntax &getAbsoluteRaw() const {
@@ -138,6 +141,50 @@ class SyntaxDataRef {
     return getAbsoluteRaw().getPosition().getIndexInParent();
   }
 
+  /// If \c this node has a child at \p Cursor, write the child's \c
+  /// SyntaxDataRef to \p DataMem and return \c true.
+  /// If no child exists at \p Cursor, leave \p DataMem untouched and return \c
+  /// false.
+  template <typename CursorType>
+  bool getChildRef(CursorType Cursor, SyntaxDataRef *DataMem) const {
+    return getChildRef(
+        (AbsoluteSyntaxPosition::IndexInParentType)cursorIndex(Cursor),
+        DataMem);
+  }
+
+  /// If \c this node has a child at \p Index, write the child's \c
+  /// SyntaxDataRef to \p DataMem and return \c true. If no child exists at \p
+  /// Index, leave \p DataMem untouched and return \c false.
+  bool getChildRef(AbsoluteSyntaxPosition::IndexInParentType Index,
+                   SyntaxDataRef *DataMem) const {
+    auto AbsoluteRaw = getAbsoluteRaw().getChild(Index);
+    if (AbsoluteRaw) {
+      new (DataMem) SyntaxDataRef(*AbsoluteRaw,
+                                  /*Parent=*/const_cast<SyntaxDataRef *>(this));
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /// Assuming that the child at \p Cursor exists, write its \c SyntaxData to \p
+  /// DataMem.
+  template <typename CursorType>
+  void getPresentChildRef(CursorType Cursor, SyntaxDataRef *DataMem) const {
+    return getPresentChildRef(
+        (AbsoluteSyntaxPosition::IndexInParentType)cursorIndex(Cursor),
+        DataMem);
+  }
+
+  /// Assuming that the child at \p Index exists, write its \c SyntaxData to \p
+  /// DataMem.
+  void getPresentChildRef(AbsoluteSyntaxPosition::IndexInParentType Index,
+                          SyntaxDataRef *DataMem) const {
+    auto AbsoluteRaw = getAbsoluteRaw().getPresentChild(Index);
+    new (DataMem) SyntaxDataRef(AbsoluteRaw,
+                                /*Parent=*/const_cast<SyntaxDataRef *>(this));
+  }
+
   // MARK: - Retrieving source locations
 
   /// Get the offset at which the leading trivia of this node starts.