Update for UnresolvedTernaryExpr syntax

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -343,6 +343,12 @@ extension SyntaxNode {
     return BooleanLiteralExprSyntax(asSyntaxData)
   }
 
+  public var isUnresolvedTernaryExpr: Bool { return raw.kind == .unresolvedTernaryExpr }
+  public var asUnresolvedTernaryExpr: UnresolvedTernaryExprSyntax? {
+    guard isUnresolvedTernaryExpr else { return nil }
+    return UnresolvedTernaryExprSyntax(asSyntaxData)
+  }
+
   public var isTernaryExpr: Bool { return raw.kind == .ternaryExpr }
   public var asTernaryExpr: TernaryExprSyntax? {
     guard isTernaryExpr else { return nil }
@@ -1705,6 +1711,8 @@ extension Syntax {
       return node
     case .booleanLiteralExpr(let node):
       return node
+    case .unresolvedTernaryExpr(let node):
+      return node
     case .ternaryExpr(let node):
       return node
     case .memberAccessExpr(let node):

Sources/SwiftSyntax/gyb_generated/RawSyntaxNodes.swift

@@ -53,7 +53,7 @@ public struct RawDeclSyntax: RawDeclSyntaxNodeProtocol {
 public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true
     default: return false
     }
   }
@@ -2380,6 +2380,65 @@ public struct RawBooleanLiteralExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol {
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .unresolvedTernaryExpr
+  }
+
+  public var raw: RawSyntax
+  init(raw: RawSyntax) {
+    assert(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
+    guard Self.isKindOf(other.raw) else { return nil }
+    self.init(raw: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? = nil,
+    questionMark: RawTokenSyntax,
+    _ unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? = nil,
+    firstChoice: RawExprSyntax,
+    _ unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? = nil,
+    colonMark: RawTokenSyntax,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .unresolvedTernaryExpr, uninitializedCount: 6, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeQuestionMark?.raw
+      layout[1] = questionMark.raw
+      layout[2] = unexpectedBetweenQuestionMarkAndFirstChoice?.raw
+      layout[3] = firstChoice.raw
+      layout[4] = unexpectedBetweenFirstChoiceAndColonMark?.raw
+      layout[5] = colonMark.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeQuestionMark: RawUnexpectedNodesSyntax? {
+    raw.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var questionMark: RawTokenSyntax {
+    raw.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenQuestionMarkAndFirstChoice: RawUnexpectedNodesSyntax? {
+    raw.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var firstChoice: RawExprSyntax {
+    raw.children[3].map(RawExprSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenFirstChoiceAndColonMark: RawUnexpectedNodesSyntax? {
+    raw.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var colonMark: RawTokenSyntax {
+    raw.children[5].map(RawTokenSyntax.init(raw:))!
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   public static func isKindOf(_ raw: RawSyntax) -> Bool {

Sources/SwiftSyntax/gyb_generated/RawSyntaxValidation.swift

@@ -342,6 +342,15 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[1], as: RawTokenSyntax.self)
     break
+  case .unresolvedTernaryExpr:
+    assert(layout.count == 6)
+    _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[1], as: RawTokenSyntax.self)
+    _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[3], as: RawExprSyntax.self)
+    _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[5], as: RawTokenSyntax.self)
+    break
   case .ternaryExpr:
     assert(layout.count == 10)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -439,6 +439,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: BooleanLiteralExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: UnresolvedTernaryExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: UnresolvedTernaryExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: TernaryExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -159,7 +159,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       self._syntaxNode = syntax
     default:
       return nil
@@ -173,7 +173,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -70,6 +70,7 @@ public enum SyntaxEnum {
   case dictionaryElement(DictionaryElementSyntax)
   case integerLiteralExpr(IntegerLiteralExprSyntax)
   case booleanLiteralExpr(BooleanLiteralExprSyntax)
+  case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
   case ternaryExpr(TernaryExprSyntax)
   case memberAccessExpr(MemberAccessExprSyntax)
   case isExpr(IsExprSyntax)
@@ -394,6 +395,8 @@ public extension Syntax {
       return .integerLiteralExpr(IntegerLiteralExprSyntax(self)!)
     case .booleanLiteralExpr:
       return .booleanLiteralExpr(BooleanLiteralExprSyntax(self)!)
+    case .unresolvedTernaryExpr:
+      return .unresolvedTernaryExpr(UnresolvedTernaryExprSyntax(self)!)
     case .ternaryExpr:
       return .ternaryExpr(TernaryExprSyntax(self)!)
     case .memberAccessExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -1144,6 +1144,35 @@ public enum SyntaxFactory {
     ], length: .zero, presence: presence))
     return BooleanLiteralExprSyntax(data)
   }
+  @available(*, deprecated, message: "Use initializer on UnresolvedTernaryExprSyntax")
+  public static func makeUnresolvedTernaryExpr(_ unexpectedBeforeQuestionMark: UnexpectedNodesSyntax? = nil, questionMark: TokenSyntax, _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, firstChoice: ExprSyntax, _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, colonMark: TokenSyntax) -> UnresolvedTernaryExprSyntax {
+    let layout: [RawSyntax?] = [
+      unexpectedBeforeQuestionMark?.raw,
+      questionMark.raw,
+      unexpectedBetweenQuestionMarkAndFirstChoice?.raw,
+      firstChoice.raw,
+      unexpectedBetweenFirstChoiceAndColonMark?.raw,
+      colonMark.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.unresolvedTernaryExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return UnresolvedTernaryExprSyntax(data)
+  }
+
+  @available(*, deprecated, message: "Use initializer on UnresolvedTernaryExprSyntax")
+  public static func makeBlankUnresolvedTernaryExpr(presence: SourcePresence = .present) -> UnresolvedTernaryExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .unresolvedTernaryExpr,
+      layout: [
+      nil,
+      RawSyntax.missingToken(TokenKind.infixQuestionMark),
+      nil,
+      RawSyntax.missing(SyntaxKind.missingExpr),
+      nil,
+      RawSyntax.missingToken(TokenKind.colon),
+    ], length: .zero, presence: presence))
+    return UnresolvedTernaryExprSyntax(data)
+  }
   @available(*, deprecated, message: "Use initializer on TernaryExprSyntax")
   public static func makeTernaryExpr(_ unexpectedBeforeConditionExpression: UnexpectedNodesSyntax? = nil, conditionExpression: ExprSyntax, _ unexpectedBetweenConditionExpressionAndQuestionMark: UnexpectedNodesSyntax? = nil, questionMark: TokenSyntax, _ unexpectedBetweenQuestionMarkAndFirstChoice: UnexpectedNodesSyntax? = nil, firstChoice: ExprSyntax, _ unexpectedBetweenFirstChoiceAndColonMark: UnexpectedNodesSyntax? = nil, colonMark: TokenSyntax, _ unexpectedBetweenColonMarkAndSecondChoice: UnexpectedNodesSyntax? = nil, secondChoice: ExprSyntax) -> TernaryExprSyntax {
     let layout: [RawSyntax?] = [

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -70,6 +70,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case dictionaryElement = 99
   case integerLiteralExpr = 47
   case booleanLiteralExpr = 49
+  case unresolvedTernaryExpr = 270
   case ternaryExpr = 50
   case memberAccessExpr = 51
   case isExpr = 53

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -401,6 +401,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `UnresolvedTernaryExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: UnresolvedTernaryExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `TernaryExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2474,6 +2481,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplUnresolvedTernaryExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = UnresolvedTernaryExprSyntax(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 Syntax(visit(node))
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplTernaryExprSyntax(_ data: SyntaxData) -> Syntax {
       let node = TernaryExprSyntax(data)
@@ -4694,6 +4711,8 @@ open class SyntaxRewriter {
       return visitImplIntegerLiteralExprSyntax
     case .booleanLiteralExpr:
       return visitImplBooleanLiteralExprSyntax
+    case .unresolvedTernaryExpr:
+      return visitImplUnresolvedTernaryExprSyntax
     case .ternaryExpr:
       return visitImplTernaryExprSyntax
     case .memberAccessExpr:
@@ -5229,6 +5248,8 @@ open class SyntaxRewriter {
       return visitImplIntegerLiteralExprSyntax(data)
     case .booleanLiteralExpr:
       return visitImplBooleanLiteralExprSyntax(data)
+    case .unresolvedTernaryExpr:
+      return visitImplUnresolvedTernaryExprSyntax(data)
     case .ternaryExpr:
       return visitImplTernaryExprSyntax(data)
     case .memberAccessExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -581,6 +581,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `BooleanLiteralExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: BooleanLiteralExprSyntax) {}
+  /// Visiting `UnresolvedTernaryExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: UnresolvedTernaryExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `UnresolvedTernaryExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: UnresolvedTernaryExprSyntax) {}
   /// Visiting `TernaryExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -3313,6 +3323,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplUnresolvedTernaryExprSyntax(_ data: SyntaxData) {
+      let node = UnresolvedTernaryExprSyntax(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 visitImplTernaryExprSyntax(_ data: SyntaxData) {
       let node = TernaryExprSyntax(data)
@@ -5707,6 +5728,8 @@ open class SyntaxVisitor {
       visitImplIntegerLiteralExprSyntax(data)
     case .booleanLiteralExpr:
       visitImplBooleanLiteralExprSyntax(data)
+    case .unresolvedTernaryExpr:
+      visitImplUnresolvedTernaryExprSyntax(data)
     case .ternaryExpr:
       visitImplTernaryExprSyntax(data)
     case .memberAccessExpr: