Update for the availability in @_specialize attribute change

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -871,6 +871,12 @@ extension SyntaxNode {
     return SpecializeAttributeSpecListSyntax(asSyntaxData)
   }
 
+  public var isAvailabilityEntry: Bool { return raw.kind == .availabilityEntry }
+  public var asAvailabilityEntry: AvailabilityEntrySyntax? {
+    guard isAvailabilityEntry else { return nil }
+    return AvailabilityEntrySyntax(asSyntaxData)
+  }
+
   public var isLabeledSpecializeEntry: Bool { return raw.kind == .labeledSpecializeEntry }
   public var asLabeledSpecializeEntry: LabeledSpecializeEntrySyntax? {
     guard isLabeledSpecializeEntry else { return nil }
@@ -1765,6 +1771,8 @@ extension Syntax {
       return node
     case .specializeAttributeSpecList(let node):
       return node
+    case .availabilityEntry(let node):
+      return node
     case .labeledSpecializeEntry(let node):
       return node
     case .targetFunctionEntry(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1058,6 +1058,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: SpecializeAttributeSpecListSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: AvailabilityEntrySyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: AvailabilityEntrySyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: LabeledSpecializeEntrySyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -6245,6 +6245,74 @@ extension AttributeSyntax {
   }
 }
 
+public struct AvailabilityEntrySyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 4)
+
+  internal init() {}
+
+  public mutating func useLabel(_ node: TokenSyntax) {
+    let idx = AvailabilityEntrySyntax.Cursor.label.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useColon(_ node: TokenSyntax) {
+    let idx = AvailabilityEntrySyntax.Cursor.colon.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func addAvailability(_ elt: AvailabilityArgumentSyntax) {
+    let idx = AvailabilityEntrySyntax.Cursor.availabilityList.rawValue
+    if let list = layout[idx] {
+      layout[idx] = list.appending(elt.raw)
+    } else {
+      layout[idx] = RawSyntax.create(kind: SyntaxKind.availabilitySpecList,
+        layout: [elt.raw], length: elt.raw.totalLength,
+        presence: SourcePresence.present)
+    }
+  }
+
+  public mutating func useSemicolon(_ node: TokenSyntax) {
+    let idx = AvailabilityEntrySyntax.Cursor.semicolon.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.availabilitySpecList)
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missingToken(TokenKind.semicolon)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .availabilityEntry,
+      layout: layout, presence: .present))
+  }
+}
+
+extension AvailabilityEntrySyntax {
+  /// Creates a `AvailabilityEntrySyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that will be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `AvailabilityEntrySyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `AvailabilityEntrySyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout AvailabilityEntrySyntaxBuilder) -> Void) {
+    var builder = AvailabilityEntrySyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct LabeledSpecializeEntrySyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 4)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -163,6 +163,7 @@ public enum SyntaxEnum {
   case attribute(AttributeSyntax)
   case attributeList(AttributeListSyntax)
   case specializeAttributeSpecList(SpecializeAttributeSpecListSyntax)
+  case availabilityEntry(AvailabilityEntrySyntax)
   case labeledSpecializeEntry(LabeledSpecializeEntrySyntax)
   case targetFunctionEntry(TargetFunctionEntrySyntax)
   case namedAttributeStringArgument(NamedAttributeStringArgumentSyntax)
@@ -564,6 +565,8 @@ public extension Syntax {
       return .attributeList(AttributeListSyntax(self)!)
     case .specializeAttributeSpecList:
       return .specializeAttributeSpecList(SpecializeAttributeSpecListSyntax(self)!)
+    case .availabilityEntry:
+      return .availabilityEntry(AvailabilityEntrySyntax(self)!)
     case .labeledSpecializeEntry:
       return .labeledSpecializeEntry(LabeledSpecializeEntrySyntax(self)!)
     case .targetFunctionEntry:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -2857,6 +2857,29 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return SpecializeAttributeSpecListSyntax(data)
   }
+  public static func makeAvailabilityEntry(label: TokenSyntax, colon: TokenSyntax, availabilityList: AvailabilitySpecListSyntax, semicolon: TokenSyntax) -> AvailabilityEntrySyntax {
+    let layout: [RawSyntax?] = [
+      label.raw,
+      colon.raw,
+      availabilityList.raw,
+      semicolon.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.availabilityEntry,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return AvailabilityEntrySyntax(data)
+  }
+
+  public static func makeBlankAvailabilityEntry() -> AvailabilityEntrySyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .availabilityEntry,
+      layout: [
+      RawSyntax.missingToken(TokenKind.identifier("")),
+      RawSyntax.missingToken(TokenKind.colon),
+      RawSyntax.missing(SyntaxKind.availabilitySpecList),
+      RawSyntax.missingToken(TokenKind.semicolon),
+    ], length: .zero, presence: .present))
+    return AvailabilityEntrySyntax(data)
+  }
   public static func makeLabeledSpecializeEntry(label: TokenSyntax, colon: TokenSyntax, value: TokenSyntax, trailingComma: TokenSyntax?) -> LabeledSpecializeEntrySyntax {
     let layout: [RawSyntax?] = [
       label.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -163,6 +163,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case attribute = 132
   case attributeList = 187
   case specializeAttributeSpecList = 188
+  case availabilityEntry = 252
   case labeledSpecializeEntry = 133
   case targetFunctionEntry = 248
   case namedAttributeStringArgument = 227

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1017,6 +1017,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `AvailabilityEntrySyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: AvailabilityEntrySyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `LabeledSpecializeEntrySyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3207,6 +3214,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplAvailabilityEntrySyntax(_ data: SyntaxData) -> Syntax {
+      let node = AvailabilityEntrySyntax(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 visitImplLabeledSpecializeEntrySyntax(_ data: SyntaxData) -> Syntax {
       let node = LabeledSpecializeEntrySyntax(data)
@@ -4523,6 +4540,8 @@ open class SyntaxRewriter {
       return visitImplAttributeListSyntax
     case .specializeAttributeSpecList:
       return visitImplSpecializeAttributeSpecListSyntax
+    case .availabilityEntry:
+      return visitImplAvailabilityEntrySyntax
     case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax
     case .targetFunctionEntry:
@@ -5026,6 +5045,8 @@ open class SyntaxRewriter {
       return visitImplAttributeListSyntax(data)
     case .specializeAttributeSpecList:
       return visitImplSpecializeAttributeSpecListSyntax(data)
+    case .availabilityEntry:
+      return visitImplAvailabilityEntrySyntax(data)
     case .labeledSpecializeEntry:
       return visitImplLabeledSpecializeEntrySyntax(data)
     case .targetFunctionEntry:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -1452,6 +1452,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `SpecializeAttributeSpecListSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SpecializeAttributeSpecListSyntax) {}
+  /// Visiting `AvailabilityEntrySyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: AvailabilityEntrySyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `AvailabilityEntrySyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: AvailabilityEntrySyntax) {}
   /// Visiting `LabeledSpecializeEntrySyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4062,6 +4072,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplAvailabilityEntrySyntax(_ data: SyntaxData) {
+      let node = AvailabilityEntrySyntax(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 visitImplLabeledSpecializeEntrySyntax(_ data: SyntaxData) {
       let node = LabeledSpecializeEntrySyntax(data)
@@ -5443,6 +5464,8 @@ open class SyntaxVisitor {
       visitImplAttributeListSyntax(data)
     case .specializeAttributeSpecList:
       visitImplSpecializeAttributeSpecListSyntax(data)
+    case .availabilityEntry:
+      visitImplAvailabilityEntrySyntax(data)
     case .labeledSpecializeEntry:
       visitImplLabeledSpecializeEntrySyntax(data)
     case .targetFunctionEntry: