Move children accessors from RawSyntax to RawSyntaxLayoutView

Author: ahoppen

Sources/SwiftSyntax/Raw/RawSyntax.swift

@@ -142,31 +142,6 @@ extension RawSyntax {
     kind.isUnknown
   }
 
-  /// Child nodes.
-  var children: RawSyntaxBuffer {
-    switch rawData.payload {
-    case .parsedToken(_),
-         .materializedToken(_):
-      return .init(start: nil, count: 0)
-    case .layout(let dat):
-      return dat.layout
-    }
-  }
-
-  func child(at index: Int) -> RawSyntax? {
-    guard hasChild(at: index) else { return nil }
-    return children[index]
-  }
-
-  func hasChild(at index: Int) -> Bool {
-    children[index] != nil
-  }
-
-  /// The number of children, `present` or `missing`, in this node.
-  var numberOfChildren: Int {
-    return children.count
-  }
-
   /// Total number of nodes in this sub-tree, including `self` node.
   var totalNodes: Int {
     switch rawData.payload {
@@ -226,7 +201,7 @@ extension RawSyntax {
         trailingTrivia: tokenView.formTrailingTrivia(),
         arena: arena)
     case .layout(let layoutView):
-      for (index, child) in children.enumerated() {
+      for (index, child) in layoutView.children.enumerated() {
         if let replaced = child?.withLeadingTrivia(leadingTrivia) {
           return layoutView.replacingChild(at: index, with: replaced, arena: arena)
         }
@@ -248,22 +223,14 @@ extension RawSyntax {
         trailingTrivia: trailingTrivia,
         arena: arena)
     case .layout(let layoutView):
-      for (index, child) in children.enumerated().reversed() {
+      for (index, child) in layoutView.children.enumerated().reversed() {
         if let replaced = child?.withTrailingTrivia(trailingTrivia) {
           return layoutView.replacingChild(at: index, with: replaced, arena: arena)
         }
       }
       return nil
     }
   }
-
-  /// Returns the child at the provided cursor in the layout.
-  /// - Parameter index: The index of the child you're accessing.
-  /// - Returns: The child at the provided index.
-  subscript<CursorType: RawRepresentable>(_ index: CursorType) -> RawSyntax?
-    where CursorType.RawValue == Int {
-    return child(at: index.rawValue)
-  }
 }
 
 extension RawSyntax {
@@ -313,8 +280,8 @@ extension RawSyntax {
     switch view {
     case .token(let tokenView):
       return tokenView
-    case .layout:
-      for child in children {
+    case .layout(let layoutView):
+      for child in layoutView.children {
         if let token = child?.firstToken(viewMode: viewMode) {
           return token
         }
@@ -329,8 +296,8 @@ extension RawSyntax {
     switch view {
     case .token(let tokenView):
       return tokenView
-    case .layout:
-      for child in children.reversed() {
+    case .layout(let layoutView):
+      for child in layoutView.children.reversed() {
         if let token = child?.lastToken(viewMode: viewMode) {
           return token
         }
@@ -628,8 +595,15 @@ extension RawSyntax: CustomDebugStringConvertible {
 
 extension RawSyntax: CustomReflectable {
   public var customMirror: Mirror {
-    let mirrorChildren: [Any] = children.map {
-      child in child ?? (nil as Any?) as Any
+
+    let mirrorChildren: [Any]
+    switch view {
+    case .token:
+      mirrorChildren = []
+    case .layout(let layoutView):
+      mirrorChildren = layoutView.children.map {
+        child in child ?? (nil as Any?) as Any
+      }
     }
     return Mirror(self, unlabeledChildren: mirrorChildren)
   }

Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift

@@ -55,11 +55,11 @@ struct RawSyntaxLayoutView {
     at index: Int,
     arena: SyntaxArena
   ) -> RawSyntax {
-    precondition(raw.children.count >= index)
+    precondition(children.count >= index)
     return .makeLayout(kind: raw.kind,
-                       uninitializedCount: raw.children.count + 1,
+                       uninitializedCount: children.count + 1,
                        arena: arena) { buffer in
-      var childIterator = raw.children.makeIterator()
+      var childIterator = children.makeIterator()
       let base = buffer.baseAddress!
       for i in 0..<buffer.count {
         base.advanced(by: i)
@@ -72,27 +72,27 @@ struct RawSyntaxLayoutView {
     at index: Int,
     arena: SyntaxArena
   ) -> RawSyntax {
-    precondition(raw.children.count > index)
-    let count = raw.children.count - 1
+    precondition(children.count > index)
+    let count = children.count - 1
     return .makeLayout(kind: raw.kind,
                        uninitializedCount: count,
                        arena: arena) { buffer in
       if buffer.isEmpty { return }
       let newBase = buffer.baseAddress!
-      let oldBase = raw.children.baseAddress!
+      let oldBase = children.baseAddress!
 
       // Copy elements up to the index.
       newBase.initialize(from: oldBase, count: index)
 
       // Copy elements from the index + 1.
       newBase.advanced(by: index)
         .initialize(from: oldBase.advanced(by: index + 1),
-                    count: raw.children.count - index - 1)
+                    count: children.count - index - 1)
     }
   }
 
   func appending(_ newChild: RawSyntax?, arena: SyntaxArena) -> RawSyntax {
-    insertingChild(newChild, at: raw.children.count, arena: arena)
+    insertingChild(newChild, at: children.count, arena: arena)
   }
 
   func replacingChildSubrange<C: Collection>(
@@ -101,22 +101,22 @@ struct RawSyntaxLayoutView {
     arena: SyntaxArena
   ) -> RawSyntax where C.Element == RawSyntax? {
     precondition(!raw.isToken)
-    let newCount = raw.children.count - range.count + elements.count
+    let newCount = children.count - range.count + elements.count
     return .makeLayout(kind: raw.kind,
                        uninitializedCount: newCount,
                        arena: arena) { buffer in
       if buffer.isEmpty { return }
       var current = buffer.baseAddress!
 
       // Intialize
-      current.initialize(from: raw.children.baseAddress!, count: range.lowerBound)
+      current.initialize(from: children.baseAddress!, count: range.lowerBound)
       current = current.advanced(by: range.lowerBound)
       for elem in elements {
         current.initialize(to: elem)
         current += 1
       }
-      current.initialize(from: raw.children.baseAddress!.advanced(by: range.upperBound),
-                         count: raw.children.count - range.upperBound)
+      current.initialize(from: children.baseAddress!.advanced(by: range.upperBound),
+                         count: children.count - range.upperBound)
     }
   }
 
@@ -125,17 +125,50 @@ struct RawSyntaxLayoutView {
     with newChild: RawSyntax?,
     arena: SyntaxArena
   ) -> RawSyntax {
-    precondition(!raw.isToken && raw.children.count > index)
+    precondition(!raw.isToken && children.count > index)
     return .makeLayout(kind: raw.kind,
-                       uninitializedCount: raw.children.count,
+                       uninitializedCount: children.count,
                        arena: arena) { buffer in
-      _ = buffer.initialize(from: raw.children)
+      _ = buffer.initialize(from: children)
       buffer[index] = newChild
     }
   }
 
   func formLayoutArray() -> [RawSyntax?] {
-    Array(raw.children)
+    Array(children)
+  }
+
+  /// Child nodes.
+  var children: RawSyntaxBuffer {
+    switch raw.rawData.payload {
+    case .parsedToken(_),
+         .materializedToken(_):
+      preconditionFailure("RawSyntax must be a layout")
+    case .layout(let dat):
+      return dat.layout
+    }
+  }
+
+  func child(at index: Int) -> RawSyntax? {
+    guard hasChild(at: index) else { return nil }
+    return children[index]
+  }
+
+  func hasChild(at index: Int) -> Bool {
+    children[index] != nil
+  }
+
+  /// Returns the child at the provided cursor in the layout.
+  /// - Parameter index: The index of the child you're accessing.
+  /// - Returns: The child at the provided index.
+  subscript<CursorType: RawRepresentable>(_ index: CursorType) -> RawSyntax?
+    where CursorType.RawValue == Int {
+    return child(at: index.rawValue)
+  }
+
+  /// The number of children, `present` or `missing`, in this node.
+  var numberOfChildren: Int {
+    return children.count
   }
 }
 

Sources/SwiftSyntax/Raw/RawSyntaxNodes.swift.gyb

@@ -29,6 +29,10 @@ public protocol Raw${node.name}NodeProtocol: Raw${node.base_type}NodeProtocol {}
 
 @_spi(RawSyntax)
 public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_type}NodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
 %   if node.is_base():
 %     sub_kinds = ['.' + n.swift_syntax_kind for n in SYNTAX_NODES if n.base_kind == node.syntax_kind]
@@ -65,7 +69,7 @@ public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_t
   }
 
   public var elements: [Raw${node.collection_element_type}] {
-    raw.children.map { Raw${node.collection_element_type}(raw: $0!) }
+    layoutView.children.map { Raw${node.collection_element_type}(raw: $0!) }
   }
 %   end
 %
@@ -100,9 +104,9 @@ public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_t
 %       iuo_mark = "!" if not child.is_optional else ""
   public var ${child.swift_name}: Raw${child.type_name + optional_mark} {
 %       if child.type_name == "Syntax":
-    raw.children[${idx}]${iuo_mark}
+    layoutView.children[${idx}]${iuo_mark}
 %       else:
-    raw.children[${idx}].map(Raw${child.type_name}.init(raw:))${iuo_mark}
+    layoutView.children[${idx}].map(Raw${child.type_name}.init(raw:))${iuo_mark}
 %       end
   }
 %     end