[Parser] Simplify sequence expression parsing

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -61,7 +61,7 @@ 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, .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
+    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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true
     default: return false
     }
   }
@@ -2836,13 +2836,13 @@ public struct RawMemberAccessExprSyntax: RawExprSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol {
+public struct RawUnresolvedIsExprSyntax: RawExprSyntaxNodeProtocol {
   var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .isExpr
+    return raw.kind == .unresolvedIsExpr
   }
 
   public var raw: RawSyntax
@@ -2859,17 +2859,13 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol {
   public init(
     _ unexpectedBeforeIsTok: RawUnexpectedNodesSyntax? = nil,
     isTok: RawTokenSyntax,
-    _ unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? = nil,
-    typeName: RawTypeSyntax,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .isExpr, uninitializedCount: 4, arena: arena) { layout in
+      kind: .unresolvedIsExpr, uninitializedCount: 2, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeIsTok?.raw
       layout[1] = isTok.raw
-      layout[2] = unexpectedBetweenIsTokAndTypeName?.raw
-      layout[3] = typeName.raw
     }
     self.init(raw: raw)
   }
@@ -2880,22 +2876,79 @@ public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol {
   public var isTok: RawTokenSyntax {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
-  public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? {
+}
+
+@_spi(RawSyntax)
+public struct RawIsExprSyntax: RawExprSyntaxNodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .isExpr
+  }
+
+  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(
+    _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil,
+    expression: RawExprSyntax,
+    _ unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? = nil,
+    isTok: RawTokenSyntax,
+    _ unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? = nil,
+    typeName: RawTypeSyntax,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .isExpr, uninitializedCount: 6, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeExpression?.raw
+      layout[1] = expression.raw
+      layout[2] = unexpectedBetweenExpressionAndIsTok?.raw
+      layout[3] = isTok.raw
+      layout[4] = unexpectedBetweenIsTokAndTypeName?.raw
+      layout[5] = typeName.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var expression: RawExprSyntax {
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenExpressionAndIsTok: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+  public var isTok: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenIsTokAndTypeName: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
   public var typeName: RawTypeSyntax {
-    layoutView.children[3].map(RawTypeSyntax.init(raw:))!
+    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
   }
 }
 
 @_spi(RawSyntax)
-public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol {
+public struct RawUnresolvedAsExprSyntax: RawExprSyntaxNodeProtocol {
   var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .asExpr
+    return raw.kind == .unresolvedAsExpr
   }
 
   public var raw: RawSyntax
@@ -2914,19 +2967,15 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol {
     asTok: RawTokenSyntax,
     _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil,
     questionOrExclamationMark: RawTokenSyntax?,
-    _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? = nil,
-    typeName: RawTypeSyntax,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .asExpr, uninitializedCount: 6, arena: arena) { layout in
+      kind: .unresolvedAsExpr, uninitializedCount: 4, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAsTok?.raw
       layout[1] = asTok.raw
       layout[2] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw
       layout[3] = questionOrExclamationMark?.raw
-      layout[4] = unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw
-      layout[5] = typeName.raw
     }
     self.init(raw: raw)
   }
@@ -2943,11 +2992,78 @@ public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol {
   public var questionOrExclamationMark: RawTokenSyntax? {
     layoutView.children[3].map(RawTokenSyntax.init(raw:))
   }
-  public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? {
+}
+
+@_spi(RawSyntax)
+public struct RawAsExprSyntax: RawExprSyntaxNodeProtocol {
+  var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .asExpr
+  }
+
+  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(
+    _ unexpectedBeforeExpression: RawUnexpectedNodesSyntax? = nil,
+    expression: RawExprSyntax,
+    _ unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? = nil,
+    asTok: RawTokenSyntax,
+    _ unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? = nil,
+    questionOrExclamationMark: RawTokenSyntax?,
+    _ unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? = nil,
+    typeName: RawTypeSyntax,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .asExpr, uninitializedCount: 8, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeExpression?.raw
+      layout[1] = expression.raw
+      layout[2] = unexpectedBetweenExpressionAndAsTok?.raw
+      layout[3] = asTok.raw
+      layout[4] = unexpectedBetweenAsTokAndQuestionOrExclamationMark?.raw
+      layout[5] = questionOrExclamationMark?.raw
+      layout[6] = unexpectedBetweenQuestionOrExclamationMarkAndTypeName?.raw
+      layout[7] = typeName.raw
+    }
+    self.init(raw: raw)
+  }
+
+  public var unexpectedBeforeExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var expression: RawExprSyntax {
+    layoutView.children[1].map(RawExprSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenExpressionAndAsTok: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var asTok: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenAsTokAndQuestionOrExclamationMark: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+  public var questionOrExclamationMark: RawTokenSyntax? {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
+  }
+  public var unexpectedBetweenQuestionOrExclamationMarkAndTypeName: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
   public var typeName: RawTypeSyntax {
-    layoutView.children[5].map(RawTypeSyntax.init(raw:))!
+    layoutView.children[7].map(RawTypeSyntax.init(raw:))!
   }
 }
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -375,21 +375,37 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     _verify(layout[6], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[7], as: RawDeclNameArgumentsSyntax?.self)
     break
+  case .unresolvedIsExpr:
+    assert(layout.count == 2)
+    _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[1], as: RawTokenSyntax.self)
+    break
   case .isExpr:
+    assert(layout.count == 6)
+    _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[1], as: RawExprSyntax.self)
+    _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[3], as: RawTokenSyntax.self)
+    _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[5], as: RawTypeSyntax.self)
+    break
+  case .unresolvedAsExpr:
     assert(layout.count == 4)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[1], as: RawTokenSyntax.self)
     _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[3], as: RawTypeSyntax.self)
+    _verify(layout[3], as: RawTokenSyntax?.self)
     break
   case .asExpr:
-    assert(layout.count == 6)
+    assert(layout.count == 8)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[1], as: RawTokenSyntax.self)
+    _verify(layout[1], as: RawExprSyntax.self)
     _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[3], as: RawTokenSyntax?.self)
+    _verify(layout[3], as: RawTokenSyntax.self)
     _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[5], as: RawTypeSyntax.self)
+    _verify(layout[5], as: RawTokenSyntax?.self)
+    _verify(layout[6], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[7], as: RawTypeSyntax.self)
     break
   case .typeExpr:
     assert(layout.count == 2)

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -361,12 +361,24 @@ extension SyntaxNode {
     return MemberAccessExprSyntax(asSyntaxData)
   }
 
+  public var isUnresolvedIsExpr: Bool { return raw.kind == .unresolvedIsExpr }
+  public var asUnresolvedIsExpr: UnresolvedIsExprSyntax? {
+    guard isUnresolvedIsExpr else { return nil }
+    return UnresolvedIsExprSyntax(asSyntaxData)
+  }
+
   public var isIsExpr: Bool { return raw.kind == .isExpr }
   public var asIsExpr: IsExprSyntax? {
     guard isIsExpr else { return nil }
     return IsExprSyntax(asSyntaxData)
   }
 
+  public var isUnresolvedAsExpr: Bool { return raw.kind == .unresolvedAsExpr }
+  public var asUnresolvedAsExpr: UnresolvedAsExprSyntax? {
+    guard isUnresolvedAsExpr else { return nil }
+    return UnresolvedAsExprSyntax(asSyntaxData)
+  }
+
   public var isAsExpr: Bool { return raw.kind == .asExpr }
   public var asAsExpr: AsExprSyntax? {
     guard isAsExpr else { return nil }
@@ -1717,8 +1729,12 @@ extension Syntax {
       return node
     case .memberAccessExpr(let node):
       return node
+    case .unresolvedIsExpr(let node):
+      return node
     case .isExpr(let node):
       return node
+    case .unresolvedAsExpr(let node):
+      return node
     case .asExpr(let node):
       return node
     case .typeExpr(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -460,13 +460,27 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: MemberAccessExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: UnresolvedIsExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: UnresolvedIsExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: IsExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
 
   override open func visitPost(_ node: IsExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: UnresolvedAsExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: UnresolvedAsExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: AsExprSyntax) -> 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, .unresolvedTernaryExpr, .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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .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, .unresolvedTernaryExpr, .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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .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

@@ -73,7 +73,9 @@ public enum SyntaxEnum {
   case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
   case ternaryExpr(TernaryExprSyntax)
   case memberAccessExpr(MemberAccessExprSyntax)
+  case unresolvedIsExpr(UnresolvedIsExprSyntax)
   case isExpr(IsExprSyntax)
+  case unresolvedAsExpr(UnresolvedAsExprSyntax)
   case asExpr(AsExprSyntax)
   case typeExpr(TypeExprSyntax)
   case closureCaptureItem(ClosureCaptureItemSyntax)
@@ -401,8 +403,12 @@ public extension Syntax {
       return .ternaryExpr(TernaryExprSyntax(self)!)
     case .memberAccessExpr:
       return .memberAccessExpr(MemberAccessExprSyntax(self)!)
+    case .unresolvedIsExpr:
+      return .unresolvedIsExpr(UnresolvedIsExprSyntax(self)!)
     case .isExpr:
       return .isExpr(IsExprSyntax(self)!)
+    case .unresolvedAsExpr:
+      return .unresolvedAsExpr(UnresolvedAsExprSyntax(self)!)
     case .asExpr:
       return .asExpr(AsExprSyntax(self)!)
     case .typeExpr: