Autodiff updates for enabling accessor derivatives …

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1928,6 +1928,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "4bfa1e0be5331f20c60a9cd4e1a32ce39b42dcd1"
+      "7b2f9ca5e9d7140a7fadb9bb5da4f23b1836bdf3"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -6541,7 +6541,7 @@ extension DifferentiabilityParamSyntax {
 
 public struct DerivativeRegistrationAttributeArgumentsSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 5)
+    Array<RawSyntax?>(repeating: nil, count: 7)
 
   internal init() {}
 
@@ -6560,6 +6560,16 @@ public struct DerivativeRegistrationAttributeArgumentsSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func usePeriod(_ node: TokenSyntax) {
+    let idx = DerivativeRegistrationAttributeArgumentsSyntax.Cursor.period.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useAccessorKind(_ node: TokenSyntax) {
+    let idx = DerivativeRegistrationAttributeArgumentsSyntax.Cursor.accessorKind.rawValue
+    layout[idx] = node.raw
+  }
+
   public mutating func useComma(_ node: TokenSyntax) {
     let idx = DerivativeRegistrationAttributeArgumentsSyntax.Cursor.comma.rawValue
     layout[idx] = node.raw

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -3005,11 +3005,13 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return DifferentiabilityParamSyntax(data)
   }
-  public static func makeDerivativeRegistrationAttributeArguments(ofLabel: TokenSyntax, colon: TokenSyntax, originalDeclName: QualifiedDeclNameSyntax, comma: TokenSyntax?, diffParams: DifferentiabilityParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
+  public static func makeDerivativeRegistrationAttributeArguments(ofLabel: TokenSyntax, colon: TokenSyntax, originalDeclName: QualifiedDeclNameSyntax, period: TokenSyntax?, accessorKind: TokenSyntax?, comma: TokenSyntax?, diffParams: DifferentiabilityParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
     let layout: [RawSyntax?] = [
       ofLabel.raw,
       colon.raw,
       originalDeclName.raw,
+      period?.raw,
+      accessorKind?.raw,
       comma?.raw,
       diffParams?.raw,
     ]
@@ -3027,6 +3029,8 @@ public enum SyntaxFactory {
       RawSyntax.missing(SyntaxKind.qualifiedDeclName),
       nil,
       nil,
+      nil,
+      nil,
     ], length: .zero, presence: .present))
     return DerivativeRegistrationAttributeArgumentsSyntax(data)
   }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -7788,6 +7788,8 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
     case ofLabel
     case colon
     case originalDeclName
+    case period
+    case accessorKind
     case comma
     case diffParams
   }
@@ -7882,6 +7884,55 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
     return DerivativeRegistrationAttributeArgumentsSyntax(newData)
   }
 
+  /// 
+  /// The period separating the original declaration name and the
+  /// accessor name.
+  /// 
+  public var period: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.period,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withPeriod(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `period` replaced.
+  /// - param newChild: The new `period` to replace the node's
+  ///                   current `period`, if present.
+  public func withPeriod(
+    _ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.period)
+    return DerivativeRegistrationAttributeArgumentsSyntax(newData)
+  }
+
+  /// The accessor name.
+  public var accessorKind: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.accessorKind,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withAccessorKind(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `accessorKind` replaced.
+  /// - param newChild: The new `accessorKind` to replace the node's
+  ///                   current `accessorKind`, if present.
+  public func withAccessorKind(
+    _ newChild: TokenSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.accessorKind)
+    return DerivativeRegistrationAttributeArgumentsSyntax(newData)
+  }
+
   public var comma: TokenSyntax? {
     get {
       let childData = data.child(at: Cursor.comma,
@@ -7929,7 +7980,7 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
 
   public func _validateLayout() {
     let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
-    assert(rawChildren.count == 5)
+    assert(rawChildren.count == 7)
     // Check child #0 child is TokenSyntax 
     assert(rawChildren[0].raw != nil)
     if let raw = rawChildren[0].raw {
@@ -7965,12 +8016,28 @@ public struct DerivativeRegistrationAttributeArgumentsSyntax: SyntaxProtocol, Sy
       let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #4 child is DifferentiabilityParamsClauseSyntax or missing
+    // Check child #4 child is TokenSyntax or missing
     if let raw = rawChildren[4].raw {
       let info = rawChildren[4].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(TokenSyntax.self))
+    }
+    // Check child #5 child is TokenSyntax or missing
+    if let raw = rawChildren[5].raw {
+      let info = rawChildren[5].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(TokenSyntax.self))
+    }
+    // Check child #6 child is DifferentiabilityParamsClauseSyntax or missing
+    if let raw = rawChildren[6].raw {
+      let info = rawChildren[6].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(DifferentiabilityParamsClauseSyntax.self))
     }
   }
@@ -7982,6 +8049,8 @@ extension DerivativeRegistrationAttributeArgumentsSyntax: CustomReflectable {
       "ofLabel": Syntax(ofLabel).asProtocol(SyntaxProtocol.self),
       "colon": Syntax(colon).asProtocol(SyntaxProtocol.self),
       "originalDeclName": Syntax(originalDeclName).asProtocol(SyntaxProtocol.self),
+      "period": period.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "accessorKind": accessorKind.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "diffParams": diffParams.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])