Regenerate with the addition of UnsafeExprSyntax

Author: DougGregor

Sources/SwiftParser/generated/ExperimentalFeatures.swift

@@ -48,6 +48,9 @@ extension Parser.ExperimentalFeatures {
   /// Whether to enable the parsing of @abi attribute.
   public static let abiAttribute = Self (rawValue: 1 << 7)
 
+  /// Whether to enable the parsing of 'unsafe' expression.
+  public static let unsafeExpression = Self (rawValue: 1 << 8)
+
   /// Creates a new value representing the experimental feature with the
   /// given name, or returns nil if the name is not recognized.
   public init?(name: String) {
@@ -68,6 +71,8 @@ extension Parser.ExperimentalFeatures {
       self = .valueGenerics
     case "ABIAttribute":
       self = .abiAttribute
+    case "WarnUnsafe":
+      self = .unsafeExpression
     default:
       return nil
     }

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -399,6 +399,8 @@ extension SyntaxKind {
       return "'is'"
     case .unresolvedTernaryExpr:
       return "ternary operator"
+    case .unsafeExpr:
+      return "'unsafe' expression"
     case .valueBindingPattern:
       return "value binding pattern"
     case .variableDecl:

Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift

@@ -3387,6 +3387,16 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "colon"
   case \UnresolvedTernaryExprSyntax.unexpectedAfterColon:
     return "unexpectedAfterColon"
+  case \UnsafeExprSyntax.unexpectedBeforeUnsafeKeyword:
+    return "unexpectedBeforeUnsafeKeyword"
+  case \UnsafeExprSyntax.unsafeKeyword:
+    return "unsafeKeyword"
+  case \UnsafeExprSyntax.unexpectedBetweenUnsafeKeywordAndExpression:
+    return "unexpectedBetweenUnsafeKeywordAndExpression"
+  case \UnsafeExprSyntax.expression:
+    return "expression"
+  case \UnsafeExprSyntax.unexpectedAfterExpression:
+    return "unexpectedAfterExpression"
   case \ValueBindingPatternSyntax.unexpectedBeforeBindingSpecifier:
     return "unexpectedBeforeBindingSpecifier"
   case \ValueBindingPatternSyntax.bindingSpecifier:

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -2268,6 +2268,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visit(_ node: UnsafeExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visitPost(_ node: UnsafeExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: ValueBindingPatternSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -542,7 +542,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init?(_ node: __shared some SyntaxProtocol) {
     switch node.raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, ._canImportExpr, ._canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, ._canImportExpr, ._canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr, .unsafeExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -619,7 +619,8 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
       .node(TypeExprSyntax.self),
       .node(UnresolvedAsExprSyntax.self),
       .node(UnresolvedIsExprSyntax.self),
-      .node(UnresolvedTernaryExprSyntax.self)
+      .node(UnresolvedTernaryExprSyntax.self),
+      .node(UnsafeExprSyntax.self)
     ])
   }
 }
@@ -1789,6 +1790,7 @@ extension Syntax {
       .node(UnresolvedAsExprSyntax.self),
       .node(UnresolvedIsExprSyntax.self),
       .node(UnresolvedTernaryExprSyntax.self),
+      .node(UnsafeExprSyntax.self),
       .node(ValueBindingPatternSyntax.self),
       .node(VariableDeclSyntax.self),
       .node(VersionComponentListSyntax.self),

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -305,6 +305,10 @@ public enum SyntaxEnum: Sendable {
   case unresolvedAsExpr(UnresolvedAsExprSyntax)
   case unresolvedIsExpr(UnresolvedIsExprSyntax)
   case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case unsafeExpr(UnsafeExprSyntax)
   case valueBindingPattern(ValueBindingPatternSyntax)
   case variableDecl(VariableDeclSyntax)
   case versionComponentList(VersionComponentListSyntax)
@@ -869,6 +873,8 @@ extension Syntax {
       return .unresolvedIsExpr(UnresolvedIsExprSyntax(self)!)
     case .unresolvedTernaryExpr:
       return .unresolvedTernaryExpr(UnresolvedTernaryExprSyntax(self)!)
+    case .unsafeExpr:
+      return .unsafeExpr(UnsafeExprSyntax(self)!)
     case .valueBindingPattern:
       return .valueBindingPattern(ValueBindingPatternSyntax(self)!)
     case .variableDecl:
@@ -1041,6 +1047,10 @@ public enum ExprSyntaxEnum {
   case unresolvedAsExpr(UnresolvedAsExprSyntax)
   case unresolvedIsExpr(UnresolvedIsExprSyntax)
   case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case unsafeExpr(UnsafeExprSyntax)
 }
 
 extension ExprSyntax {
@@ -1153,6 +1163,8 @@ extension ExprSyntax {
       return .unresolvedIsExpr(UnresolvedIsExprSyntax(self)!)
     case .unresolvedTernaryExpr:
       return .unresolvedTernaryExpr(UnresolvedTernaryExprSyntax(self)!)
+    case .unsafeExpr:
+      return .unsafeExpr(UnsafeExprSyntax(self)!)
     default:
       preconditionFailure("unknown Expr syntax kind")
     }

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -305,6 +305,10 @@ public enum SyntaxKind: Sendable {
   case unresolvedAsExpr
   case unresolvedIsExpr
   case unresolvedTernaryExpr
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case unsafeExpr
   case valueBindingPattern
   case variableDecl
   case versionComponentList
@@ -994,6 +998,8 @@ public enum SyntaxKind: Sendable {
       return UnresolvedIsExprSyntax.self
     case .unresolvedTernaryExpr:
       return UnresolvedTernaryExprSyntax.self
+    case .unsafeExpr:
+      return UnsafeExprSyntax.self
     case .valueBindingPattern:
       return ValueBindingPatternSyntax.self
     case .variableDecl:

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -2020,6 +2020,16 @@ open class SyntaxRewriter {
     return ExprSyntax(UnresolvedTernaryExprSyntax(unsafeCasting: visitChildren(node._syntaxNode)))
   }
 
+  /// Visit a `UnsafeExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: UnsafeExprSyntax) -> ExprSyntax {
+    return ExprSyntax(UnsafeExprSyntax(unsafeCasting: visitChildren(node._syntaxNode)))
+  }
+
   /// Visit a ``ValueBindingPatternSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3504,6 +3514,11 @@ open class SyntaxRewriter {
     Syntax(visit(UnresolvedTernaryExprSyntax(unsafeCasting: node)))
   }
 
+  @inline(never)
+  private func visitUnsafeExprSyntaxImpl(_ node: Syntax) -> Syntax {
+    Syntax(visit(UnsafeExprSyntax(unsafeCasting: node)))
+  }
+
   @inline(never)
   private func visitValueBindingPatternSyntaxImpl(_ node: Syntax) -> Syntax {
     Syntax(visit(ValueBindingPatternSyntax(unsafeCasting: node)))
@@ -4136,6 +4151,8 @@ open class SyntaxRewriter {
       return self.visitUnresolvedIsExprSyntaxImpl(_:)
     case .unresolvedTernaryExpr:
       return self.visitUnresolvedTernaryExprSyntaxImpl(_:)
+    case .unsafeExpr:
+      return self.visitUnsafeExprSyntaxImpl(_:)
     case .valueBindingPattern:
       return self.visitValueBindingPatternSyntaxImpl(_:)
     case .variableDecl:
@@ -4714,6 +4731,8 @@ open class SyntaxRewriter {
       return visitUnresolvedIsExprSyntaxImpl(node)
     case .unresolvedTernaryExpr:
       return visitUnresolvedTernaryExprSyntaxImpl(node)
+    case .unsafeExpr:
+      return visitUnsafeExprSyntaxImpl(node)
     case .valueBindingPattern:
       return visitValueBindingPatternSyntaxImpl(node)
     case .variableDecl:

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -3334,6 +3334,24 @@ open class SyntaxVisitor {
   open func visitPost(_ node: UnresolvedTernaryExprSyntax) {
   }
 
+  /// Visiting `UnsafeExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: UnsafeExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `UnsafeExprSyntax` and its descendants.
+  ///   - node: the node we just finished visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visitPost(_ node: UnsafeExprSyntax) {
+  }
+
   /// Visiting ``ValueBindingPatternSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -5673,6 +5691,14 @@ open class SyntaxVisitor {
     visitPost(UnresolvedTernaryExprSyntax(unsafeCasting: node))
   }
 
+  @inline(never)
+  private func visitUnsafeExprSyntaxImpl(_ node: Syntax) {
+    if visit(UnsafeExprSyntax(unsafeCasting: node)) == .visitChildren {
+      visitChildren(node)
+    }
+    visitPost(UnsafeExprSyntax(unsafeCasting: node))
+  }
+
   @inline(never)
   private func visitValueBindingPatternSyntaxImpl(_ node: Syntax) {
     if visit(ValueBindingPatternSyntax(unsafeCasting: node)) == .visitChildren {
@@ -6341,6 +6367,8 @@ open class SyntaxVisitor {
       return self.visitUnresolvedIsExprSyntaxImpl(_:)
     case .unresolvedTernaryExpr:
       return self.visitUnresolvedTernaryExprSyntaxImpl(_:)
+    case .unsafeExpr:
+      return self.visitUnsafeExprSyntaxImpl(_:)
     case .valueBindingPattern:
       return self.visitValueBindingPatternSyntaxImpl(_:)
     case .variableDecl:
@@ -6919,6 +6947,8 @@ open class SyntaxVisitor {
       self.visitUnresolvedIsExprSyntaxImpl(node)
     case .unresolvedTernaryExpr:
       self.visitUnresolvedTernaryExprSyntaxImpl(node)
+    case .unsafeExpr:
+      self.visitUnsafeExprSyntaxImpl(node)
     case .valueBindingPattern:
       self.visitValueBindingPatternSyntaxImpl(node)
     case .variableDecl:

Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift

@@ -988,7 +988,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, ._canImportExpr, ._canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr:
+    case .arrayExpr, .arrowExpr, .asExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr, .booleanLiteralExpr, .borrowExpr, ._canImportExpr, ._canImportVersionInfo, .closureExpr, .consumeExpr, .copyExpr, .declReferenceExpr, .dictionaryExpr, .discardAssignmentExpr, .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr, .functionCallExpr, .genericSpecializationExpr, .ifExpr, .inOutExpr, .infixOperatorExpr, .integerLiteralExpr, .isExpr, .keyPathExpr, .macroExpansionExpr, .memberAccessExpr, .missingExpr, .nilLiteralExpr, .optionalChainingExpr, .packElementExpr, .packExpansionExpr, .patternExpr, .postfixIfConfigExpr, .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr, .simpleStringLiteralExpr, .stringLiteralExpr, .subscriptCallExpr, .superExpr, .switchExpr, .ternaryExpr, .tryExpr, .tupleExpr, .typeExpr, .unresolvedAsExpr, .unresolvedIsExpr, .unresolvedTernaryExpr, .unsafeExpr:
       return true
     default:
       return false

Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift

@@ -1955,6 +1955,79 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
+#if compiler(>=5.8)
+@_spi(ExperimentalLanguageFeatures)
+#endif
+@_spi(RawSyntax)
+public struct RawUnsafeExprSyntax: RawExprSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .unsafeExpr
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeUnsafeKeyword: RawUnexpectedNodesSyntax? = nil,
+    unsafeKeyword: RawTokenSyntax,
+    _ unexpectedBetweenUnsafeKeywordAndExpression: RawUnexpectedNodesSyntax? = nil,
+    expression: some RawExprSyntaxNodeProtocol,
+    _ unexpectedAfterExpression: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .unsafeExpr, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeUnsafeKeyword?.raw
+      layout[1] = unsafeKeyword.raw
+      layout[2] = unexpectedBetweenUnsafeKeywordAndExpression?.raw
+      layout[3] = expression.raw
+      layout[4] = unexpectedAfterExpression?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeUnsafeKeyword: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var unsafeKeyword: RawTokenSyntax {
+    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenUnsafeKeywordAndExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var expression: RawExprSyntax {
+    layoutView.children[3].map(RawExprSyntax.init(raw:))!
+  }
+
+  public var unexpectedAfterExpression: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawValueBindingPatternSyntax: RawPatternSyntaxNodeProtocol {
   @_spi(RawSyntax)

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -2973,6 +2973,14 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.colon)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
   }
+  func validateUnsafeExprSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) {
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("unsafe")]))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawExprSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+  }
   func validateValueBindingPatternSyntax(kind: SyntaxKind, layout: RawSyntaxBuffer) {
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -3632,6 +3640,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     validateUnresolvedIsExprSyntax(kind: kind, layout: layout)
   case .unresolvedTernaryExpr:
     validateUnresolvedTernaryExprSyntax(kind: kind, layout: layout)
+  case .unsafeExpr:
+    validateUnsafeExprSyntax(kind: kind, layout: layout)
   case .valueBindingPattern:
     validateValueBindingPatternSyntax(kind: kind, layout: layout)
   case .variableDecl: