diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift
index f2924dc38d4..2418eb422e9 100644
--- a/Sources/SwiftSyntax/gyb_generated/Misc.swift
+++ b/Sources/SwiftSyntax/gyb_generated/Misc.swift
@@ -873,6 +873,12 @@ extension SyntaxNode {
     return LabeledSpecializeEntrySyntax(asSyntaxData)
   }
 
+  public var isTargetFunctionEntry: Bool { return raw.kind == .targetFunctionEntry }
+  public var asTargetFunctionEntry: TargetFunctionEntrySyntax? {
+    guard isTargetFunctionEntry else { return nil }
+    return TargetFunctionEntrySyntax(asSyntaxData)
+  }
+
   public var isNamedAttributeStringArgument: Bool { return raw.kind == .namedAttributeStringArgument }
   public var asNamedAttributeStringArgument: NamedAttributeStringArgumentSyntax? {
     guard isNamedAttributeStringArgument else { return nil }
@@ -1749,6 +1755,8 @@ extension Syntax {
       return node
     case .labeledSpecializeEntry(let node):
       return node
+    case .targetFunctionEntry(let node):
+      return node
     case .namedAttributeStringArgument(let node):
       return node
     case .declName(let node):
@@ -1944,6 +1952,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "26709743ccc5ea2001419f44996c8fa671901c03"
+      "0741fb1877365f4e66ca42dc7d84d31d7ccdd35a"
   }
 }
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift
index 2562484d358..0c9ba6faaef 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift
@@ -1058,6 +1058,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: LabeledSpecializeEntrySyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: TargetFunctionEntrySyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: TargetFunctionEntrySyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: NamedAttributeStringArgumentSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
index 84079e8af10..45a862dc5ff 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
@@ -6240,6 +6240,65 @@ extension LabeledSpecializeEntrySyntax {
   }
 }
 
+public struct TargetFunctionEntrySyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 4)
+
+  internal init() {}
+
+  public mutating func useLabel(_ node: TokenSyntax) {
+    let idx = TargetFunctionEntrySyntax.Cursor.label.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useColon(_ node: TokenSyntax) {
+    let idx = TargetFunctionEntrySyntax.Cursor.colon.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useDelcname(_ node: DeclNameSyntax) {
+    let idx = TargetFunctionEntrySyntax.Cursor.delcname.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useTrailingComma(_ node: TokenSyntax) {
+    let idx = TargetFunctionEntrySyntax.Cursor.trailingComma.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.identifier(""))
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.colon)
+    }
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missing(SyntaxKind.declName)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .targetFunctionEntry,
+      layout: layout, presence: .present))
+  }
+}
+
+extension TargetFunctionEntrySyntax {
+  /// Creates a `TargetFunctionEntrySyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that wil be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `TargetFunctionEntrySyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `TargetFunctionEntrySyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout TargetFunctionEntrySyntaxBuilder) -> Void) {
+    var builder = TargetFunctionEntrySyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct NamedAttributeStringArgumentSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 3)
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift
index 8ec9156b2ff..bb9f1ca55cf 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift
@@ -163,6 +163,7 @@ public enum SyntaxEnum {
   case attributeList(AttributeListSyntax)
   case specializeAttributeSpecList(SpecializeAttributeSpecListSyntax)
   case labeledSpecializeEntry(LabeledSpecializeEntrySyntax)
+  case targetFunctionEntry(TargetFunctionEntrySyntax)
   case namedAttributeStringArgument(NamedAttributeStringArgumentSyntax)
   case declName(DeclNameSyntax)
   case implementsAttributeArguments(ImplementsAttributeArgumentsSyntax)
@@ -561,6 +562,8 @@ public extension Syntax {
       return .specializeAttributeSpecList(SpecializeAttributeSpecListSyntax(self)!)
     case .labeledSpecializeEntry:
       return .labeledSpecializeEntry(LabeledSpecializeEntrySyntax(self)!)
+    case .targetFunctionEntry:
+      return .targetFunctionEntry(TargetFunctionEntrySyntax(self)!)
     case .namedAttributeStringArgument:
       return .namedAttributeStringArgument(NamedAttributeStringArgumentSyntax(self)!)
     case .declName:
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
index dd410d280c2..b484e725bb4 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
@@ -2841,6 +2841,29 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return LabeledSpecializeEntrySyntax(data)
   }
+  public static func makeTargetFunctionEntry(label: TokenSyntax, colon: TokenSyntax, delcname: DeclNameSyntax, trailingComma: TokenSyntax?) -> TargetFunctionEntrySyntax {
+    let layout: [RawSyntax?] = [
+      label.raw,
+      colon.raw,
+      delcname.raw,
+      trailingComma?.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.targetFunctionEntry,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return TargetFunctionEntrySyntax(data)
+  }
+
+  public static func makeBlankTargetFunctionEntry() -> TargetFunctionEntrySyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .targetFunctionEntry,
+      layout: [
+      RawSyntax.missingToken(TokenKind.identifier("")),
+      RawSyntax.missingToken(TokenKind.colon),
+      RawSyntax.missing(SyntaxKind.declName),
+      nil,
+    ], length: .zero, presence: .present))
+    return TargetFunctionEntrySyntax(data)
+  }
   public static func makeNamedAttributeStringArgument(nameTok: TokenSyntax, colon: TokenSyntax, stringOrDeclname: Syntax) -> NamedAttributeStringArgumentSyntax {
     let layout: [RawSyntax?] = [
       nameTok.raw,
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift
index 59e955e8427..b9081dc92d5 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift
@@ -163,6 +163,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case attributeList = 187
   case specializeAttributeSpecList = 188
   case labeledSpecializeEntry = 133
+  case targetFunctionEntry = 248
   case namedAttributeStringArgument = 227
   case declName = 228
   case implementsAttributeArguments = 134
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
index 85d120e502f..b019698ab40 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
@@ -1017,6 +1017,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `TargetFunctionEntrySyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: TargetFunctionEntrySyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `NamedAttributeStringArgumentSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3188,6 +3195,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplTargetFunctionEntrySyntax(_ data: SyntaxData) -> Syntax {
+      let node = TargetFunctionEntrySyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return visit(node)
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplNamedAttributeStringArgumentSyntax(_ data: SyntaxData) -> Syntax {
       let node = NamedAttributeStringArgumentSyntax(data)
@@ -4474,6 +4491,8 @@ open class SyntaxRewriter {
       return visitImplSpecializeAttributeSpecListSyntax
     case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax
+    case .targetFunctionEntry:
+      return visitImplTargetFunctionEntrySyntax
     case .namedAttributeStringArgument:
       return visitImplNamedAttributeStringArgumentSyntax
     case .declName:
@@ -4971,6 +4990,8 @@ open class SyntaxRewriter {
       return visitImplSpecializeAttributeSpecListSyntax(data)
     case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax(data)
+    case .targetFunctionEntry:
+      return visitImplTargetFunctionEntrySyntax(data)
     case .namedAttributeStringArgument:
       return visitImplNamedAttributeStringArgumentSyntax(data)
     case .declName:
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift
index 067fa62645a..777f351bc78 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift
@@ -243,6 +243,7 @@ extension EnumDeclSyntax: IdentifiedDeclSyntax {}
 extension OperatorDeclSyntax: IdentifiedDeclSyntax {}
 extension PrecedenceGroupDeclSyntax: IdentifiedDeclSyntax {}
 extension LabeledSpecializeEntrySyntax: WithTrailingCommaSyntax {}
+extension TargetFunctionEntrySyntax: WithTrailingCommaSyntax {}
 extension DifferentiabilityParamSyntax: WithTrailingCommaSyntax {}
 extension WhileStmtSyntax: WithCodeBlockSyntax, LabeledSyntax {}
 extension DeferStmtSyntax: WithCodeBlockSyntax {}
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
index def8457b19d..277a5cc20dd 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
@@ -1452,6 +1452,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `LabeledSpecializeEntrySyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: LabeledSpecializeEntrySyntax) {}
+  /// Visiting `TargetFunctionEntrySyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: TargetFunctionEntrySyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `TargetFunctionEntrySyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: TargetFunctionEntrySyntax) {}
   /// Visiting `NamedAttributeStringArgumentSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4034,6 +4044,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplTargetFunctionEntrySyntax(_ data: SyntaxData) {
+      let node = TargetFunctionEntrySyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplNamedAttributeStringArgumentSyntax(_ data: SyntaxData) {
       let node = NamedAttributeStringArgumentSyntax(data)
@@ -5382,6 +5403,8 @@ open class SyntaxVisitor {
       visitImplSpecializeAttributeSpecListSyntax(data)
     case .labeledSpecializeEntry:
       visitImplLabeledSpecializeEntrySyntax(data)
+    case .targetFunctionEntry:
+      visitImplTargetFunctionEntrySyntax(data)
     case .namedAttributeStringArgument:
       visitImplNamedAttributeStringArgumentSyntax(data)
     case .declName:
diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift
index e3dc9c9b2b4..1d612c7d0a0 100644
--- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift
+++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift
@@ -6733,6 +6733,186 @@ extension LabeledSpecializeEntrySyntax: CustomReflectable {
   }
 }
 
+// MARK: - TargetFunctionEntrySyntax
+
+/// 
+/// A labeled argument for the `@_specialize` attribute with a function
+/// decl value like
+/// `target: myFunc(_:)`
+/// 
+public struct TargetFunctionEntrySyntax: SyntaxProtocol, SyntaxHashable {
+  enum Cursor: Int {
+    case label
+    case colon
+    case delcname
+    case trailingComma
+  }
+
+  public let _syntaxNode: Syntax
+
+  /// Converts the given `Syntax` node to a `TargetFunctionEntrySyntax` if possible. Returns
+  /// `nil` if the conversion is not possible.
+  public init?(_ syntax: Syntax) {
+    guard syntax.raw.kind == .targetFunctionEntry else { return nil }
+    self._syntaxNode = syntax
+  }
+
+  /// Creates a `TargetFunctionEntrySyntax` node from the given `SyntaxData`. This assumes
+  /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
+  /// is undefined.
+  internal init(_ data: SyntaxData) {
+    assert(data.raw.kind == .targetFunctionEntry)
+    self._syntaxNode = Syntax(data)
+  }
+
+  public var syntaxNodeType: SyntaxProtocol.Type {
+    return Swift.type(of: self)
+  }
+
+  /// The label of the argument
+  public var label: TokenSyntax {
+    get {
+      let childData = data.child(at: Cursor.label,
+                                 parent: Syntax(self))
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withLabel(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `label` replaced.
+  /// - param newChild: The new `label` to replace the node's
+  ///                   current `label`, if present.
+  public func withLabel(
+    _ newChild: TokenSyntax?) -> TargetFunctionEntrySyntax {
+    let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.identifier(""))
+    let newData = data.replacingChild(raw, at: Cursor.label)
+    return TargetFunctionEntrySyntax(newData)
+  }
+
+  /// The colon separating the label and the value
+  public var colon: TokenSyntax {
+    get {
+      let childData = data.child(at: Cursor.colon,
+                                 parent: Syntax(self))
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withColon(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `colon` replaced.
+  /// - param newChild: The new `colon` to replace the node's
+  ///                   current `colon`, if present.
+  public func withColon(
+    _ newChild: TokenSyntax?) -> TargetFunctionEntrySyntax {
+    let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.colon)
+    let newData = data.replacingChild(raw, at: Cursor.colon)
+    return TargetFunctionEntrySyntax(newData)
+  }
+
+  /// The value for this argument
+  public var delcname: DeclNameSyntax {
+    get {
+      let childData = data.child(at: Cursor.delcname,
+                                 parent: Syntax(self))
+      return DeclNameSyntax(childData!)
+    }
+    set(value) {
+      self = withDelcname(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `delcname` replaced.
+  /// - param newChild: The new `delcname` to replace the node's
+  ///                   current `delcname`, if present.
+  public func withDelcname(
+    _ newChild: DeclNameSyntax?) -> TargetFunctionEntrySyntax {
+    let raw = newChild?.raw ?? RawSyntax.missing(SyntaxKind.declName)
+    let newData = data.replacingChild(raw, at: Cursor.delcname)
+    return TargetFunctionEntrySyntax(newData)
+  }
+
+  /// 
+  /// A trailing comma if this argument is followed by another one
+  /// 
+  public var trailingComma: TokenSyntax? {
+    get {
+      let childData = data.child(at: Cursor.trailingComma,
+                                 parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withTrailingComma(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `trailingComma` replaced.
+  /// - param newChild: The new `trailingComma` to replace the node's
+  ///                   current `trailingComma`, if present.
+  public func withTrailingComma(
+    _ newChild: TokenSyntax?) -> TargetFunctionEntrySyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: Cursor.trailingComma)
+    return TargetFunctionEntrySyntax(newData)
+  }
+
+
+  public func _validateLayout() {
+    let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
+    assert(rawChildren.count == 4)
+    // Check child #0 child is TokenSyntax 
+    assert(rawChildren[0].raw != nil)
+    if let raw = rawChildren[0].raw {
+      let info = rawChildren[0].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 #1 child is TokenSyntax 
+    assert(rawChildren[1].raw != nil)
+    if let raw = rawChildren[1].raw {
+      let info = rawChildren[1].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 #2 child is DeclNameSyntax 
+    assert(rawChildren[2].raw != nil)
+    if let raw = rawChildren[2].raw {
+      let info = rawChildren[2].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(DeclNameSyntax.self))
+    }
+    // Check child #3 child is TokenSyntax or missing
+    if let raw = rawChildren[3].raw {
+      let info = rawChildren[3].syntaxInfo
+      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
+      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
+      let syntaxChild = Syntax(syntaxData)
+      assert(syntaxChild.is(TokenSyntax.self))
+    }
+  }
+}
+
+extension TargetFunctionEntrySyntax: CustomReflectable {
+  public var customMirror: Mirror {
+    return Mirror(self, children: [
+      "label": Syntax(label).asProtocol(SyntaxProtocol.self),
+      "colon": Syntax(colon).asProtocol(SyntaxProtocol.self),
+      "delcname": Syntax(delcname).asProtocol(SyntaxProtocol.self),
+      "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+    ])
+  }
+}
+
 // MARK: - NamedAttributeStringArgumentSyntax
 
 ///