Remove syntax nodes only used for the C++ parser's handling of keypaths

CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift

@@ -1162,41 +1162,6 @@ public let EXPR_NODES: [Node] = [
                ])
        ]),
 
-  Node(name: "OldKeyPathExpr",
-       nameForDiagnostics: "key path",
-       kind: "Expr",
-       children: [
-         Child(name: "Backslash",
-               kind: "BackslashToken",
-               tokenChoices: [
-                 "Backslash"
-               ]),
-         Child(name: "RootExpr",
-               kind: "Expr",
-               isOptional: true,
-               nodeChoices: [
-                 Child(name: "IdentifierExpr",
-                       kind: "IdentifierExpr"),
-                 Child(name: "SpecializeExpr",
-                       kind: "SpecializeExpr"),
-                 Child(name: "OptionalChainingExpr",
-                       kind: "OptionalChainingExpr")
-               ]),
-         Child(name: "Expression",
-               kind: "Expr")
-       ]),
-
-  Node(name: "KeyPathBaseExpr",
-       nameForDiagnostics: nil,
-       kind: "Expr",
-       children: [
-         Child(name: "Period",
-               kind: "PeriodToken",
-               tokenChoices: [
-                 "Period"
-               ])
-       ]),
-
   Node(name: "ObjcNamePiece",
        nameForDiagnostics: nil,
        kind: "Syntax",

Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md

@@ -154,8 +154,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/StringLiteralExprSyntax>
 - <doc:SwiftSyntax/RegexLiteralExprSyntax>
 - <doc:SwiftSyntax/KeyPathExprSyntax>
-- <doc:SwiftSyntax/OldKeyPathExprSyntax>
-- <doc:SwiftSyntax/KeyPathBaseExprSyntax>
 - <doc:SwiftSyntax/ObjcKeyPathExprSyntax>
 - <doc:SwiftSyntax/ObjcSelectorExprSyntax>
 - <doc:SwiftSyntax/MacroExpansionExprSyntax>

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -65,7 +65,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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .oldKeyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .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, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true
     default: return false
     }
   }
@@ -5363,161 +5363,6 @@ public struct RawKeyPathOptionalComponentSyntax: RawSyntaxNodeProtocol {
   }
 }
 
-@_spi(RawSyntax)
-public struct RawOldKeyPathExprSyntax: RawExprSyntaxNodeProtocol {
-  @frozen // FIXME: Not actually stable, works around a miscompile
-  public enum RootExpr: RawSyntaxNodeProtocol {
-    case `identifierExpr`(RawIdentifierExprSyntax)
-    case `specializeExpr`(RawSpecializeExprSyntax)
-    case `optionalChainingExpr`(RawOptionalChainingExprSyntax)
-
-    public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return RawIdentifierExprSyntax.isKindOf(raw) || RawSpecializeExprSyntax.isKindOf(raw) || RawOptionalChainingExprSyntax.isKindOf(raw)
-    }
-
-    public var raw: RawSyntax {
-      switch self {
-      case .identifierExpr(let node): return node.raw
-      case .specializeExpr(let node): return node.raw
-      case .optionalChainingExpr(let node): return node.raw
-      }
-    }
-
-    public init?<T>(_ other: T) where T : RawSyntaxNodeProtocol {
-      if let node = RawIdentifierExprSyntax(other) {
-        self = .identifierExpr(node)
-        return
-      }
-      if let node = RawSpecializeExprSyntax(other) {
-        self = .specializeExpr(node)
-        return
-      }
-      if let node = RawOptionalChainingExprSyntax(other) {
-        self = .optionalChainingExpr(node)
-        return
-      }
-      return nil
-    }
-  }
-
-
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .oldKeyPathExpr
-  }
-
-  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(
-    _ unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? = nil,
-    backslash: RawTokenSyntax,
-    _ unexpectedBetweenBackslashAndRootExpr: RawUnexpectedNodesSyntax? = nil,
-    rootExpr: RootExpr?,
-    _ unexpectedBetweenRootExprAndExpression: RawUnexpectedNodesSyntax? = nil,
-    expression: RawExprSyntax,
-    _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .oldKeyPathExpr, uninitializedCount: 7, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeBackslash?.raw
-      layout[1] = backslash.raw
-      layout[2] = unexpectedBetweenBackslashAndRootExpr?.raw
-      layout[3] = rootExpr?.raw
-      layout[4] = unexpectedBetweenRootExprAndExpression?.raw
-      layout[5] = expression.raw
-      layout[6] = unexpectedAfterExpression?.raw
-    }
-    self.init(raw: raw)
-  }
-
-  public var unexpectedBeforeBackslash: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var backslash: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenBackslashAndRootExpr: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var rootExpr: RawExprSyntax? {
-    layoutView.children[3].map(RawExprSyntax.init(raw:))
-  }
-  public var unexpectedBetweenRootExprAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var expression: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw:))!
-  }
-  public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-}
-
-@_spi(RawSyntax)
-public struct RawKeyPathBaseExprSyntax: RawExprSyntaxNodeProtocol {
-
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .keyPathBaseExpr
-  }
-
-  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(
-    _ unexpectedBeforePeriod: RawUnexpectedNodesSyntax? = nil,
-    period: RawTokenSyntax,
-    _ unexpectedAfterPeriod: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .keyPathBaseExpr, uninitializedCount: 3, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforePeriod?.raw
-      layout[1] = period.raw
-      layout[2] = unexpectedAfterPeriod?.raw
-    }
-    self.init(raw: raw)
-  }
-
-  public var unexpectedBeforePeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var period: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedAfterPeriod: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-}
-
 @_spi(RawSyntax)
 public struct RawObjcNamePieceSyntax: RawSyntaxNodeProtocol {
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -779,26 +779,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     break
-  case .oldKeyPathExpr:
-    assert(layout.count == 7)
-    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
-    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertAnyHasNoError(kind, 3, [
-      verify(layout[3], as: RawExprSyntax?.self),
-      verify(layout[3], as: RawExprSyntax?.self),
-      verify(layout[3], as: RawExprSyntax?.self),
-    ])
-    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawExprSyntax.self))
-    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-    break
-  case .keyPathBaseExpr:
-    assert(layout.count == 3)
-    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
-    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    break
   case .objcNamePiece:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -105,8 +105,6 @@ extension Syntax {
       .node(KeyPathPropertyComponentSyntax.self),
       .node(KeyPathSubscriptComponentSyntax.self),
       .node(KeyPathOptionalComponentSyntax.self),
-      .node(OldKeyPathExprSyntax.self),
-      .node(KeyPathBaseExprSyntax.self),
       .node(ObjcNamePieceSyntax.self),
       .node(ObjcNameSyntax.self),
       .node(ObjcKeyPathExprSyntax.self),
@@ -394,8 +392,6 @@ extension SyntaxKind {
     case .keyPathPropertyComponent: return KeyPathPropertyComponentSyntax.self
     case .keyPathSubscriptComponent: return KeyPathSubscriptComponentSyntax.self
     case .keyPathOptionalComponent: return KeyPathOptionalComponentSyntax.self
-    case .oldKeyPathExpr: return OldKeyPathExprSyntax.self
-    case .keyPathBaseExpr: return KeyPathBaseExprSyntax.self
     case .objcNamePiece: return ObjcNamePieceSyntax.self
     case .objcName: return ObjcNameSyntax.self
     case .objcKeyPathExpr: return ObjcKeyPathExprSyntax.self
@@ -771,10 +767,6 @@ extension SyntaxKind {
       return "key path subscript component"
     case .keyPathOptionalComponent:
       return "key path optional component"
-    case .oldKeyPathExpr:
-      return "key path"
-    case .keyPathBaseExpr:
-      return nil
     case .objcNamePiece:
       return nil
     case .objcName:

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -677,20 +677,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: KeyPathOptionalComponentSyntax) {
     visitAnyPost(node._syntaxNode)
   }
-  override open func visit(_ node: OldKeyPathExprSyntax) -> SyntaxVisitorContinueKind {
-    return visitAny(node._syntaxNode)
-  }
-
-  override open func visitPost(_ node: OldKeyPathExprSyntax) {
-    visitAnyPost(node._syntaxNode)
-  }
-  override open func visit(_ node: KeyPathBaseExprSyntax) -> SyntaxVisitorContinueKind {
-    return visitAny(node._syntaxNode)
-  }
-
-  override open func visitPost(_ node: KeyPathBaseExprSyntax) {
-    visitAnyPost(node._syntaxNode)
-  }
   override open func visit(_ node: ObjcNamePieceSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -216,7 +216,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .oldKeyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .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, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -230,7 +230,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, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .oldKeyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .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, .objcKeyPathExpr, .objcSelectorExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")
@@ -317,8 +317,6 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
       .node(StringLiteralExprSyntax.self),
       .node(RegexLiteralExprSyntax.self),
       .node(KeyPathExprSyntax.self),
-      .node(OldKeyPathExprSyntax.self),
-      .node(KeyPathBaseExprSyntax.self),
       .node(ObjcKeyPathExprSyntax.self),
       .node(ObjcSelectorExprSyntax.self),
       .node(MacroExpansionExprSyntax.self),

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -105,8 +105,6 @@ public enum SyntaxEnum {
   case keyPathPropertyComponent(KeyPathPropertyComponentSyntax)
   case keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax)
   case keyPathOptionalComponent(KeyPathOptionalComponentSyntax)
-  case oldKeyPathExpr(OldKeyPathExprSyntax)
-  case keyPathBaseExpr(KeyPathBaseExprSyntax)
   case objcNamePiece(ObjcNamePieceSyntax)
   case objcName(ObjcNameSyntax)
   case objcKeyPathExpr(ObjcKeyPathExprSyntax)
@@ -483,10 +481,6 @@ public extension Syntax {
       return .keyPathSubscriptComponent(KeyPathSubscriptComponentSyntax(self)!)
     case .keyPathOptionalComponent:
       return .keyPathOptionalComponent(KeyPathOptionalComponentSyntax(self)!)
-    case .oldKeyPathExpr:
-      return .oldKeyPathExpr(OldKeyPathExprSyntax(self)!)
-    case .keyPathBaseExpr:
-      return .keyPathBaseExpr(KeyPathBaseExprSyntax(self)!)
     case .objcNamePiece:
       return .objcNamePiece(ObjcNamePieceSyntax(self)!)
     case .objcName: