Regenerate sources

Author: DougGregor

CodeGeneration/Sources/SyntaxSupport/gyb_generated/StmtNodes.swift

@@ -408,9 +408,7 @@ public let STMT_NODES: [Node] = [
                  Child(name: "MatchingPattern",
                        kind: "MatchingPatternCondition"),
                  Child(name: "OptionalBinding",
-                       kind: "OptionalBindingCondition"),
-                 Child(name: "HasSymbol",
-                       kind: "HasSymbolCondition")
+                       kind: "OptionalBindingCondition")
                ]),
          Child(name: "TrailingComma",
                kind: "CommaToken",
@@ -489,26 +487,6 @@ public let STMT_NODES: [Node] = [
                isOptional: true)
        ]),
 
-  Node(name: "HasSymbolCondition",
-       nameForDiagnostics: "'#_hasSymbol' condition",
-       kind: "Syntax",
-       children: [
-         Child(name: "HasSymbolKeyword",
-               kind: "HasSymbolToken"),
-         Child(name: "LeftParen",
-               kind: "LeftParenToken",
-               tokenChoices: [
-                 "LeftParen"
-               ]),
-         Child(name: "Expression",
-               kind: "Expr"),
-         Child(name: "RightParen",
-               kind: "RightParenToken",
-               tokenChoices: [
-                 "RightParen"
-               ])
-       ]),
-
   Node(name: "ConditionElementList",
        nameForDiagnostics: nil,
        kind: "SyntaxCollection",

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

@@ -379,7 +379,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/AvailabilityConditionSyntax>
 - <doc:SwiftSyntax/MatchingPatternConditionSyntax>
 - <doc:SwiftSyntax/OptionalBindingConditionSyntax>
-- <doc:SwiftSyntax/HasSymbolConditionSyntax>
 - <doc:SwiftSyntax/ConditionElementListSyntax>
 - <doc:SwiftSyntax/SwitchCaseSyntax>
 - <doc:SwiftSyntax/SwitchDefaultLabelSyntax>

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -14006,10 +14006,9 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol {
     case `availability`(RawAvailabilityConditionSyntax)
     case `matchingPattern`(RawMatchingPatternConditionSyntax)
     case `optionalBinding`(RawOptionalBindingConditionSyntax)
-    case `hasSymbol`(RawHasSymbolConditionSyntax)
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return RawExprSyntax.isKindOf(raw) || RawAvailabilityConditionSyntax.isKindOf(raw) || RawMatchingPatternConditionSyntax.isKindOf(raw) || RawOptionalBindingConditionSyntax.isKindOf(raw) || RawHasSymbolConditionSyntax.isKindOf(raw)
+      return RawExprSyntax.isKindOf(raw) || RawAvailabilityConditionSyntax.isKindOf(raw) || RawMatchingPatternConditionSyntax.isKindOf(raw) || RawOptionalBindingConditionSyntax.isKindOf(raw)
     }
 
     public var raw: RawSyntax {
@@ -14018,7 +14017,6 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol {
       case .availability(let node): return node.raw
       case .matchingPattern(let node): return node.raw
       case .optionalBinding(let node): return node.raw
-      case .hasSymbol(let node): return node.raw
       }
     }
 
@@ -14039,10 +14037,6 @@ public struct RawConditionElementSyntax: RawSyntaxNodeProtocol {
         self = .optionalBinding(node)
         return
       }
-      if let node = RawHasSymbolConditionSyntax(other) {
-        self = .hasSymbol(node)
-        return
-      }
       return nil
     }
   }
@@ -14345,86 +14339,6 @@ public struct RawOptionalBindingConditionSyntax: RawSyntaxNodeProtocol {
   }
 }
 
-@_spi(RawSyntax)
-public struct RawHasSymbolConditionSyntax: RawSyntaxNodeProtocol {
-
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .hasSymbolCondition
-  }
-
-  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(
-    _ unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? = nil,
-    hasSymbolKeyword: RawTokenSyntax,
-    _ unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil,
-    leftParen: RawTokenSyntax,
-    _ unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? = nil,
-    expression: RawExprSyntax,
-    _ unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? = nil,
-    rightParen: RawTokenSyntax,
-    _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .hasSymbolCondition, uninitializedCount: 9, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeHasSymbolKeyword?.raw
-      layout[1] = hasSymbolKeyword.raw
-      layout[2] = unexpectedBetweenHasSymbolKeywordAndLeftParen?.raw
-      layout[3] = leftParen.raw
-      layout[4] = unexpectedBetweenLeftParenAndExpression?.raw
-      layout[5] = expression.raw
-      layout[6] = unexpectedBetweenExpressionAndRightParen?.raw
-      layout[7] = rightParen.raw
-      layout[8] = unexpectedAfterRightParen?.raw
-    }
-    self.init(raw: raw)
-  }
-
-  public var unexpectedBeforeHasSymbolKeyword: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var hasSymbolKeyword: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenHasSymbolKeywordAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var leftParen: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenLeftParenAndExpression: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var expression: RawExprSyntax {
-    layoutView.children[5].map(RawExprSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenExpressionAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var rightParen: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-}
-
 @_spi(RawSyntax)
 public struct RawConditionElementListSyntax: RawSyntaxNodeProtocol {
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -2057,7 +2057,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
       verify(layout[1], as: RawSyntax.self),
       verify(layout[1], as: RawSyntax.self),
       verify(layout[1], as: RawSyntax.self),
-      verify(layout[1], as: RawSyntax.self),
     ])
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self))
@@ -2099,18 +2098,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 7, verify(layout[7], as: RawInitializerClauseSyntax?.self))
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
     break
-  case .hasSymbolCondition:
-    assert(layout.count == 9)
-    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))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.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))
-    assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax.self))
-    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
-    break
   case .conditionElementList:
     for (index, element) in layout.enumerated() {
       assertNoError(kind, index, verify(element, as: RawConditionElementSyntax.self))

Sources/SwiftSyntax/generated/Misc.swift

@@ -138,7 +138,6 @@ extension Syntax {
         .node(GenericRequirementSyntax.self), 
         .node(GenericWhereClauseSyntax.self), 
         .node(GuardStmtSyntax.self), 
-        .node(HasSymbolConditionSyntax.self), 
         .node(IdentifierExprSyntax.self), 
         .node(IdentifierPatternSyntax.self), 
         .node(IfConfigClauseListSyntax.self), 
@@ -525,8 +524,6 @@ extension SyntaxKind {
       return GenericWhereClauseSyntax.self
     case .guardStmt: 
       return GuardStmtSyntax.self
-    case .hasSymbolCondition: 
-      return HasSymbolConditionSyntax.self
     case .identifierExpr: 
       return IdentifierExprSyntax.self
     case .identifierPattern: 
@@ -1052,8 +1049,6 @@ extension SyntaxKind {
       return "'where' clause"
     case .guardStmt: 
       return "'guard' statement"
-    case .hasSymbolCondition: 
-      return "'#_hasSymbol' condition"
     case .identifierExpr: 
       return nil
     case .identifierPattern: 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -1009,14 +1009,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
-  override open func visit(_ node: HasSymbolConditionSyntax) -> SyntaxVisitorContinueKind {
-    return visitAny(node._syntaxNode)
-  }
-  
-  override open func visitPost(_ node: HasSymbolConditionSyntax) {
-    visitAnyPost(node._syntaxNode)
-  }
-  
   override open func visit(_ node: IdentifierExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -257,8 +257,6 @@ public enum SyntaxEnum {
 
   case guardStmt(GuardStmtSyntax)
 
-  case hasSymbolCondition(HasSymbolConditionSyntax)
-  
   case identifierExpr(IdentifierExprSyntax)
 
   case identifierPattern(IdentifierPatternSyntax)
@@ -784,8 +782,6 @@ public extension Syntax {
       return .genericWhereClause(GenericWhereClauseSyntax(self)!)
     case .guardStmt: 
       return .guardStmt(GuardStmtSyntax(self)!)
-    case .hasSymbolCondition: 
-      return .hasSymbolCondition(HasSymbolConditionSyntax(self)!)
     case .identifierExpr: 
       return .identifierExpr(IdentifierExprSyntax(self)!)
     case .identifierPattern: 

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -257,8 +257,6 @@ public enum SyntaxKind {
 
   case guardStmt
 
-  case hasSymbolCondition
-  
   case identifierExpr
 
   case identifierPattern

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -860,13 +860,6 @@ open class SyntaxRewriter {
     return StmtSyntax(visitChildren(node))
   }
 
-  /// Visit a `HasSymbolConditionSyntax`.
-  ///   - Parameter node: the node that is being visited
-  ///   - Returns: the rewritten node
-  open func visit(_ node: HasSymbolConditionSyntax) -> HasSymbolConditionSyntax {
-    return Syntax(visitChildren(node)).cast(HasSymbolConditionSyntax.self)
-  }
-  
   /// Visit a `IdentifierExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3587,20 +3580,6 @@ open class SyntaxRewriter {
     return Syntax(visit(node))
   }
 
-  /// Implementation detail of visit(_:). Do not call directly.
-  private func visitImplHasSymbolConditionSyntax(_ data: SyntaxData) -> Syntax {
-    let node = HasSymbolConditionSyntax(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 visitImplIdentifierExprSyntax(_ data: SyntaxData) -> Syntax {
     let node = IdentifierExprSyntax(data)
@@ -5841,8 +5820,6 @@ open class SyntaxRewriter {
       return visitImplGenericWhereClauseSyntax
     case .guardStmt: 
       return visitImplGuardStmtSyntax
-    case .hasSymbolCondition: 
-      return visitImplHasSymbolConditionSyntax
     case .identifierExpr: 
       return visitImplIdentifierExprSyntax
     case .identifierPattern: 
@@ -6371,8 +6348,6 @@ open class SyntaxRewriter {
       return visitImplGenericWhereClauseSyntax(data)
     case .guardStmt: 
       return visitImplGuardStmtSyntax(data)
-    case .hasSymbolCondition: 
-      return visitImplHasSymbolConditionSyntax(data)
     case .identifierExpr: 
       return visitImplIdentifierExprSyntax(data)
     case .identifierPattern: 

Sources/SwiftSyntax/generated/SyntaxTransform.swift

@@ -616,11 +616,6 @@ public protocol SyntaxTransformVisitor {
   ///   - Returns: the sum of whatever the child visitors return.
   func visit(_ node: GuardStmtSyntax) -> ResultType
 
-  /// Visiting `HasSymbolConditionSyntax` specifically.
-  ///   - Parameter node: the node we are visiting.
-  ///   - Returns: the sum of whatever the child visitors return.
-  func visit(_ node: HasSymbolConditionSyntax) -> ResultType
-  
   /// Visiting `IdentifierExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: the sum of whatever the child visitors return.
@@ -2160,13 +2155,6 @@ extension SyntaxTransformVisitor {
     visitAny(Syntax(node))
   }
 
-  /// Visiting `HasSymbolConditionSyntax` specifically.
-  ///   - Parameter node: the node we are visiting.
-  ///   - Returns: nil by default.
-  public func visit(_ node: HasSymbolConditionSyntax) -> ResultType {
-    visitAny(Syntax(node))
-  }
-  
   /// Visiting `IdentifierExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: nil by default.
@@ -3389,8 +3377,6 @@ extension SyntaxTransformVisitor {
       return visit(derived)
     case .guardStmt(let derived): 
       return visit(derived)
-    case .hasSymbolCondition(let derived): 
-      return visit(derived)
     case .identifierExpr(let derived): 
       return visit(derived)
     case .identifierPattern(let derived): 

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -1456,18 +1456,6 @@ open class SyntaxVisitor {
   open func visitPost(_ node: GuardStmtSyntax) {
   }
 
-  /// Visiting `HasSymbolConditionSyntax` specifically.
-  ///   - Parameter node: the node we are visiting.
-  ///   - Returns: how should we continue visiting.
-  open func visit(_ node: HasSymbolConditionSyntax) -> SyntaxVisitorContinueKind {
-    return .visitChildren
-  }
-  
-  /// The function called after visiting `HasSymbolConditionSyntax` and its descendents.
-  ///   - node: the node we just finished visiting.
-  open func visitPost(_ node: HasSymbolConditionSyntax) {
-  }
-  
   /// Visiting `IdentifierExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4469,17 +4457,6 @@ open class SyntaxVisitor {
     visitPost(node)
   }
 
-  /// Implementation detail of doVisit(_:_:). Do not call directly.
-  private func visitImplHasSymbolConditionSyntax(_ data: SyntaxData) {
-    let node = HasSymbolConditionSyntax(data)
-    let needsChildren = (visit(node) == .visitChildren)
-    // Avoid calling into visitChildren if possible.
-    if needsChildren && !node.raw.layoutView!.children.isEmpty {
-      visitChildren(node)
-    }
-    visitPost(node)
-  }
-  
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplIdentifierExprSyntax(_ data: SyntaxData) {
     let node = IdentifierExprSyntax(data)
@@ -6265,8 +6242,6 @@ open class SyntaxVisitor {
       visitImplGenericWhereClauseSyntax(data)
     case .guardStmt: 
       visitImplGuardStmtSyntax(data)
-    case .hasSymbolCondition: 
-      visitImplHasSymbolConditionSyntax(data)
     case .identifierExpr: 
       visitImplIdentifierExprSyntax(data)
     case .identifierPattern: