[SE-0290] GYB: Unavailable tokens

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1101,6 +1101,12 @@ extension SyntaxNode {
     return OptionalBindingConditionSyntax(asSyntaxData)
   }
 
+  public var isUnavailabilityCondition: Bool { return raw.kind == .unavailabilityCondition }
+  public var asUnavailabilityCondition: UnavailabilityConditionSyntax? {
+    guard isUnavailabilityCondition else { return nil }
+    return UnavailabilityConditionSyntax(asSyntaxData)
+  }
+
   public var isConditionElementList: Bool { return raw.kind == .conditionElementList }
   public var asConditionElementList: ConditionElementListSyntax? {
     guard isConditionElementList else { return nil }
@@ -1837,6 +1843,8 @@ extension Syntax {
       return node
     case .optionalBindingCondition(let node):
       return node
+    case .unavailabilityCondition(let node):
+      return node
     case .conditionElementList(let node):
       return node
     case .declarationStmt(let node):
@@ -1960,6 +1968,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "a66df9d44b9128aee3da17e9b0d2aed27ce7ec61"
+      "0b9cec009c8c03b20b21615c4b4386bb21ea5a01"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1324,6 +1324,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: OptionalBindingConditionSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: UnavailabilityConditionSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: UnavailabilityConditionSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: ConditionElementListSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -8049,6 +8049,74 @@ extension OptionalBindingConditionSyntax {
   }
 }
 
+public struct UnavailabilityConditionSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 4)
+
+  internal init() {}
+
+  public mutating func usePoundUnavailableKeyword(_ node: TokenSyntax) {
+    let idx = UnavailabilityConditionSyntax.Cursor.poundUnavailableKeyword.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useLeftParen(_ node: TokenSyntax) {
+    let idx = UnavailabilityConditionSyntax.Cursor.leftParen.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func addAvailabilityArgument(_ elt: AvailabilityArgumentSyntax) {
+    let idx = UnavailabilityConditionSyntax.Cursor.availabilitySpec.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 useRightParen(_ node: TokenSyntax) {
+    let idx = UnavailabilityConditionSyntax.Cursor.rightParen.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.poundUnavailableKeyword)
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.leftParen)
+    }
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missing(SyntaxKind.availabilitySpecList)
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missingToken(TokenKind.rightParen)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .unavailabilityCondition,
+      layout: layout, presence: .present))
+  }
+}
+
+extension UnavailabilityConditionSyntax {
+  /// Creates a `UnavailabilityConditionSyntax` 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 `UnavailabilityConditionSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `UnavailabilityConditionSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout UnavailabilityConditionSyntaxBuilder) -> Void) {
+    var builder = UnavailabilityConditionSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct DeclarationStmtSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 1)

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -328,6 +328,8 @@ extension RawTokenKind {
       return .poundDirectiveKeyword
     case .poundAvailableKeyword:
       return .keyword
+    case .poundUnavailableKeyword:
+      return .keyword
     case .poundFileLiteralKeyword:
       return .objectLiteral
     case .poundImageLiteralKeyword:

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -201,6 +201,7 @@ public enum SyntaxEnum {
   case availabilityCondition(AvailabilityConditionSyntax)
   case matchingPatternCondition(MatchingPatternConditionSyntax)
   case optionalBindingCondition(OptionalBindingConditionSyntax)
+  case unavailabilityCondition(UnavailabilityConditionSyntax)
   case conditionElementList(ConditionElementListSyntax)
   case declarationStmt(DeclarationStmtSyntax)
   case throwStmt(ThrowStmtSyntax)
@@ -639,6 +640,8 @@ public extension Syntax {
       return .matchingPatternCondition(MatchingPatternConditionSyntax(self)!)
     case .optionalBindingCondition:
       return .optionalBindingCondition(OptionalBindingConditionSyntax(self)!)
+    case .unavailabilityCondition:
+      return .unavailabilityCondition(UnavailabilityConditionSyntax(self)!)
     case .conditionElementList:
       return .conditionElementList(ConditionElementListSyntax(self)!)
     case .declarationStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -3653,6 +3653,29 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return OptionalBindingConditionSyntax(data)
   }
+  public static func makeUnavailabilityCondition(poundUnavailableKeyword: TokenSyntax, leftParen: TokenSyntax, availabilitySpec: AvailabilitySpecListSyntax, rightParen: TokenSyntax) -> UnavailabilityConditionSyntax {
+    let layout: [RawSyntax?] = [
+      poundUnavailableKeyword.raw,
+      leftParen.raw,
+      availabilitySpec.raw,
+      rightParen.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.unavailabilityCondition,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return UnavailabilityConditionSyntax(data)
+  }
+
+  public static func makeBlankUnavailabilityCondition() -> UnavailabilityConditionSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .unavailabilityCondition,
+      layout: [
+      RawSyntax.missingToken(TokenKind.poundUnavailableKeyword),
+      RawSyntax.missingToken(TokenKind.leftParen),
+      RawSyntax.missing(SyntaxKind.availabilitySpecList),
+      RawSyntax.missingToken(TokenKind.rightParen),
+    ], length: .zero, presence: .present))
+    return UnavailabilityConditionSyntax(data)
+  }
   public static func makeConditionElementList(
     _ elements: [ConditionElementSyntax]) -> ConditionElementListSyntax {
     let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.conditionElementList,
@@ -5428,6 +5451,12 @@ public enum SyntaxFactory {
                      leadingTrivia: leadingTrivia,
                      trailingTrivia: trailingTrivia)
   }
+  public static func makePoundUnavailableKeyword(leadingTrivia: Trivia = [],
+    trailingTrivia: Trivia = []) -> TokenSyntax {
+    return makeToken(.poundUnavailableKeyword, presence: .present,
+                     leadingTrivia: leadingTrivia,
+                     trailingTrivia: trailingTrivia)
+  }
   public static func makePoundFileLiteralKeyword(leadingTrivia: Trivia = [],
     trailingTrivia: Trivia = []) -> TokenSyntax {
     return makeToken(.poundFileLiteralKeyword, presence: .present,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -201,6 +201,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case availabilityCondition = 138
   case matchingPatternCondition = 139
   case optionalBindingCondition = 140
+  case unavailabilityCondition = 251
   case conditionElementList = 193
   case declarationStmt = 84
   case throwStmt = 85

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1283,6 +1283,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `UnavailabilityConditionSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: UnavailabilityConditionSyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `ConditionElementListSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3580,6 +3587,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplUnavailabilityConditionSyntax(_ data: SyntaxData) -> Syntax {
+      let node = UnavailabilityConditionSyntax(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 visitImplConditionElementListSyntax(_ data: SyntaxData) -> Syntax {
       let node = ConditionElementListSyntax(data)
@@ -4582,6 +4599,8 @@ open class SyntaxRewriter {
       return visitImplMatchingPatternConditionSyntax
     case .optionalBindingCondition:
       return visitImplOptionalBindingConditionSyntax
+    case .unavailabilityCondition:
+      return visitImplUnavailabilityConditionSyntax
     case .conditionElementList:
       return visitImplConditionElementListSyntax
     case .declarationStmt:
@@ -5083,6 +5102,8 @@ open class SyntaxRewriter {
       return visitImplMatchingPatternConditionSyntax(data)
     case .optionalBindingCondition:
       return visitImplOptionalBindingConditionSyntax(data)
+    case .unavailabilityCondition:
+      return visitImplUnavailabilityConditionSyntax(data)
     case .conditionElementList:
       return visitImplConditionElementListSyntax(data)
     case .declarationStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -1832,6 +1832,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `OptionalBindingConditionSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: OptionalBindingConditionSyntax) {}
+  /// Visiting `UnavailabilityConditionSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: UnavailabilityConditionSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `UnavailabilityConditionSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: UnavailabilityConditionSyntax) {}
   /// Visiting `ConditionElementListSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4470,6 +4480,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplUnavailabilityConditionSyntax(_ data: SyntaxData) {
+      let node = UnavailabilityConditionSyntax(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 visitImplConditionElementListSyntax(_ data: SyntaxData) {
       let node = ConditionElementListSyntax(data)
@@ -5498,6 +5519,8 @@ open class SyntaxVisitor {
       visitImplMatchingPatternConditionSyntax(data)
     case .optionalBindingCondition:
       visitImplOptionalBindingConditionSyntax(data)
+    case .unavailabilityCondition:
+      visitImplUnavailabilityConditionSyntax(data)
     case .conditionElementList:
       visitImplConditionElementListSyntax(data)
     case .declarationStmt:

Sources/SwiftSyntax/gyb_generated/TokenKind.swift

@@ -119,6 +119,7 @@ public enum TokenKind {
   case poundElseifKeyword
   case poundEndifKeyword
   case poundAvailableKeyword
+  case poundUnavailableKeyword
   case poundFileLiteralKeyword
   case poundImageLiteralKeyword
   case poundColorLiteralKeyword
@@ -246,6 +247,7 @@ public enum TokenKind {
     case .poundElseifKeyword: return "#elseif"
     case .poundEndifKeyword: return "#endif"
     case .poundAvailableKeyword: return "#available"
+    case .poundUnavailableKeyword: return "#unavailable"
     case .poundFileLiteralKeyword: return "#fileLiteral"
     case .poundImageLiteralKeyword: return "#imageLiteral"
     case .poundColorLiteralKeyword: return "#colorLiteral"
@@ -374,6 +376,7 @@ public enum TokenKind {
     case .poundElseifKeyword: return true
     case .poundEndifKeyword: return true
     case .poundAvailableKeyword: return true
+    case .poundUnavailableKeyword: return true
     case .poundFileLiteralKeyword: return true
     case .poundImageLiteralKeyword: return true
     case .poundColorLiteralKeyword: return true
@@ -502,6 +505,7 @@ public enum TokenKind {
     case .poundElseifKeyword: return "pound_elseif"
     case .poundEndifKeyword: return "pound_endif"
     case .poundAvailableKeyword: return "pound_available"
+    case .poundUnavailableKeyword: return "pound_unavailable"
     case .poundFileLiteralKeyword: return "pound_fileLiteral"
     case .poundImageLiteralKeyword: return "pound_imageLiteral"
     case .poundColorLiteralKeyword: return "pound_colorLiteral"
@@ -630,6 +634,7 @@ public enum TokenKind {
     case .poundElseifKeyword: return SourceLength(utf8Length: 7)
     case .poundEndifKeyword: return SourceLength(utf8Length: 6)
     case .poundAvailableKeyword: return SourceLength(utf8Length: 10)
+    case .poundUnavailableKeyword: return SourceLength(utf8Length: 12)
     case .poundFileLiteralKeyword: return SourceLength(utf8Length: 12)
     case .poundImageLiteralKeyword: return SourceLength(utf8Length: 13)
     case .poundColorLiteralKeyword: return SourceLength(utf8Length: 13)
@@ -760,6 +765,7 @@ extension TokenKind: Equatable {
     case (.poundElseifKeyword, .poundElseifKeyword): return true
     case (.poundEndifKeyword, .poundEndifKeyword): return true
     case (.poundAvailableKeyword, .poundAvailableKeyword): return true
+    case (.poundUnavailableKeyword, .poundUnavailableKeyword): return true
     case (.poundFileLiteralKeyword, .poundFileLiteralKeyword): return true
     case (.poundImageLiteralKeyword, .poundImageLiteralKeyword): return true
     case (.poundColorLiteralKeyword, .poundColorLiteralKeyword): return true
@@ -1009,6 +1015,8 @@ extension TokenKind {
       return .poundEndifKeyword
     case 60:
       return .poundAvailableKeyword
+    case 123:
+      return .poundUnavailableKeyword
     case 76:
       return .poundFileLiteralKeyword
     case 77:
@@ -1269,6 +1277,8 @@ extension TokenKind {
       return false
     case 60:
       return false
+    case 123:
+      return false
     case 76:
       return false
     case 77:
@@ -1418,6 +1428,7 @@ internal enum RawTokenKind: CTokenKind {
   case poundElseifKeyword = 63
   case poundEndifKeyword = 61
   case poundAvailableKeyword = 60
+  case poundUnavailableKeyword = 123
   case poundFileLiteralKeyword = 76
   case poundImageLiteralKeyword = 77
   case poundColorLiteralKeyword = 75
@@ -1761,6 +1772,9 @@ extension TokenKind {
     case .poundAvailableKeyword:
       let length = 10
       return body(.init(kind: .poundAvailableKeyword, length: length))
+    case .poundUnavailableKeyword:
+      let length = 12
+      return body(.init(kind: .poundUnavailableKeyword, length: length))
     case .poundFileLiteralKeyword:
       let length = 12
       return body(.init(kind: .poundFileLiteralKeyword, length: length))