Merge pull request #630 from rintaro/intcursor

Get rid of `XXXSyntax.Cursor` type

Author: rintaro

Sources/SwiftSyntax/Raw/RawSyntaxLayoutView.swift

@@ -153,14 +153,6 @@ struct RawSyntaxLayoutView {
     layoutData.layout
   }
 
-  /// 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 children[index.rawValue]
-  }
-
   /// The number of children, `present` or `missing`, in this node.
   var numberOfChildren: Int {
     return children.count

Sources/SwiftSyntax/SyntaxData.swift

@@ -298,22 +298,6 @@ struct SyntaxData {
     return SyntaxData(AbsoluteRawSyntax(raw: raw!, info: info), parent: parent)
   }
 
-  /// Returns the child data at the provided cursor in this data's layout.
-  /// - Note: This has O(n) performance, prefer using a proper Sequence type
-  ///         if applicable, instead of this.
-  /// - Note: This function traps if the cursor is out of the bounds of the
-  ///         data's layout.
-  ///
-  /// - Parameter cursor: The cursor to create and cache.
-  /// - Parameter parent: The parent to associate the child with. This is
-  ///             normally the Syntax node that this `SyntaxData` belongs to.
-  /// - Returns: The child's data at the provided cursor.
-  func child<CursorType: RawRepresentable>(
-    at cursor: CursorType, parent: Syntax) -> SyntaxData?
-    where CursorType.RawValue == Int {
-    return child(at: cursor.rawValue, parent: parent)
-  }
-
   /// Creates a copy of `self` and recursively creates `SyntaxData` nodes up to
   /// the root.
   /// - parameter newRaw: The new RawSyntax that will back the new `Data`
@@ -348,22 +332,6 @@ struct SyntaxData {
     return replacingSelf(newRaw)
   }
 
-  /// Creates a copy of `self` with the child at the provided cursor replaced
-  /// with a new SyntaxData containing the raw syntax provided.
-  ///
-  /// - Parameters:
-  ///   - child: The raw syntax for the new child to replace.
-  ///   - cursor: A cursor that points to the index of the child you wish to
-  ///             replace
-  /// - Returns: The new root node created by this operation, and the new child
-  ///            syntax data.
-  /// - SeeAlso: replacingSelf(_:)
-  func replacingChild<CursorType: RawRepresentable>(_ child: RawSyntax?,
-    at cursor: CursorType) -> SyntaxData
-    where CursorType.RawValue == Int {
-    return replacingChild(child, at: cursor.rawValue)
-  }
-
   func withLeadingTrivia(_ leadingTrivia: Trivia) -> SyntaxData {
     if let raw = raw.withLeadingTrivia(leadingTrivia) {
       return replacingSelf(raw)

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -47,18 +47,6 @@ nodes whose base kind are that specified kind.
 /// ${line}
 %     end
 public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
-%     # ======
-%     # Cursor
-%     # ======
-%
-%     if node.children:
-  enum Cursor: Int {
-%       for child in node.children:
-    case ${child.swift_name}
-%       end
-  }
-%     end
-
 %     # ==============
 %     # Initialization
 %     # ==============
@@ -111,7 +99,7 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
   public var syntaxNodeType: SyntaxProtocol.Type {
     return Swift.type(of: self)
   }
-%     for child in node.children:
+%     for (idx, child) in enumerate(node.children):
 %       child_node = NODE_MAP.get(child.syntax_kind)
 %
 %       # ===================
@@ -128,8 +116,7 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
 %       end
   public var ${child.swift_name}: ${ret_type} {
     get {
-      let childData = data.child(at: Cursor.${child.swift_name},
-                                 parent: Syntax(self))
+      let childData = data.child(at: ${idx}, parent: Syntax(self))
 %       if child.is_optional:
       if childData == nil { return nil }
 %       end
@@ -160,14 +147,13 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
   ///            appended to its `${child.swift_name}` collection.
   public func add${child_elt}(_ element: ${child_elt_type}) -> ${node.name} {
     var collection: RawSyntax
-    if let col = raw.layoutView![Cursor.${child.swift_name}] {
+    if let col = raw.layoutView!.children[${idx}] {
       collection = col.layoutView!.appending(element.raw, arena: .default)
     } else {
       collection = RawSyntax.makeLayout(kind: SyntaxKind.${child_node.swift_syntax_kind},
         from: [element.raw], arena: .default)
     }
-    let newData = data.replacingChild(collection,
-                                      at: Cursor.${child.swift_name})
+    let newData = data.replacingChild(collection, at: ${idx})
     return ${node.name}(newData)
   }
 %       end
@@ -185,7 +171,7 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
 %       else:
     let raw = newChild?.raw ?? ${make_missing_swift_child(child)}
 %       end
-    let newData = data.replacingChild(raw, at: Cursor.${child.swift_name})
+    let newData = data.replacingChild(raw, at: ${idx})
     return ${node.name}(newData)
   }
 %     end