[SE-0458] Enable unsafe expressions and for..in effects everywhere

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -183,7 +183,6 @@ public let EXPR_NODES: [Node] = [
   Node(
     kind: .unsafeExpr,
     base: .expr,
-    experimentalFeature: .unsafeExpression,
     nameForDiagnostics: "'unsafe' expression",
     children: [
       Child(

CodeGeneration/Sources/SyntaxSupport/StmtNodes.swift

@@ -287,7 +287,6 @@ public let STMT_NODES: [Node] = [
       Child(
         name: "unsafeKeyword",
         kind: .token(choices: [.keyword(.unsafe)]),
-        experimentalFeature: .unsafeExpression,
         isOptional: true
       ),
       Child(

Sources/SwiftParser/Expressions.swift

@@ -445,6 +445,10 @@ extension Parser {
         )
       )
     case (.unsafe, let handle)?:
+      if self.peek().isAtStartOfLine || self.peek(isAt: .rightParen) {
+        break EXPR_PREFIX
+      }
+
       let unsafeTok = self.eat(handle)
       let sub = self.parseSequenceExpressionElement(
         flavor: flavor,

Sources/SwiftParser/TokenSpecSet.swift

@@ -714,7 +714,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
     case TokenSpec(.repeat): self = .repeat
     case TokenSpec(.each): self = .each
     case TokenSpec(.any): self = .any
-    case TokenSpec(.unsafe) where experimentalFeatures.contains(.unsafeExpression): self = .unsafe
+    case TokenSpec(.unsafe): self = .unsafe
     default: return nil
     }
   }

Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md

@@ -135,6 +135,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/UnresolvedAsExprSyntax>
 - <doc:SwiftSyntax/UnresolvedIsExprSyntax>
 - <doc:SwiftSyntax/UnresolvedTernaryExprSyntax>
+- <doc:SwiftSyntax/UnsafeExprSyntax>
 
 ### Patterns
 

Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift

@@ -2294,12 +2294,10 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
-  @_spi(ExperimentalLanguageFeatures)
   override open func visit(_ node: UnsafeExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
 
-  @_spi(ExperimentalLanguageFeatures)
   override open func visitPost(_ node: UnsafeExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }

Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift

@@ -506,6 +506,7 @@ extension Syntax {
 /// - ``UnresolvedAsExprSyntax``
 /// - ``UnresolvedIsExprSyntax``
 /// - ``UnresolvedTernaryExprSyntax``
+/// - ``UnsafeExprSyntax``
 public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 

Sources/SwiftSyntax/generated/SyntaxEnum.swift

@@ -303,7 +303,6 @@ public enum SyntaxEnum: Sendable {
   case unresolvedAsExpr(UnresolvedAsExprSyntax)
   case unresolvedIsExpr(UnresolvedIsExprSyntax)
   case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
-  @_spi(ExperimentalLanguageFeatures)
   case unsafeExpr(UnsafeExprSyntax)
   case valueBindingPattern(ValueBindingPatternSyntax)
   case variableDecl(VariableDeclSyntax)
@@ -1051,7 +1050,6 @@ public enum ExprSyntaxEnum {
   case unresolvedAsExpr(UnresolvedAsExprSyntax)
   case unresolvedIsExpr(UnresolvedIsExprSyntax)
   case unresolvedTernaryExpr(UnresolvedTernaryExprSyntax)
-  @_spi(ExperimentalLanguageFeatures)
   case unsafeExpr(UnsafeExprSyntax)
 }
 

Sources/SwiftSyntax/generated/SyntaxKind.swift

@@ -303,7 +303,6 @@ public enum SyntaxKind: Sendable {
   case unresolvedAsExpr
   case unresolvedIsExpr
   case unresolvedTernaryExpr
-  @_spi(ExperimentalLanguageFeatures)
   case unsafeExpr
   case valueBindingPattern
   case variableDecl

Sources/SwiftSyntax/generated/SyntaxRewriter.swift

@@ -2048,10 +2048,9 @@ open class SyntaxRewriter {
     return ExprSyntax(UnresolvedTernaryExprSyntax(unsafeCasting: visitChildren(node._syntaxNode)))
   }
 
-  /// Visit a `UnsafeExprSyntax`.
+  /// Visit a ``UnsafeExprSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
-  @_spi(ExperimentalLanguageFeatures)
   open func visit(_ node: UnsafeExprSyntax) -> ExprSyntax {
     return ExprSyntax(UnsafeExprSyntax(unsafeCasting: visitChildren(node._syntaxNode)))
   }

Sources/SwiftSyntax/generated/SyntaxVisitor.swift

@@ -3380,17 +3380,15 @@ open class SyntaxVisitor {
   open func visitPost(_ node: UnresolvedTernaryExprSyntax) {
   }
 
-  /// Visiting `UnsafeExprSyntax` specifically.
+  /// Visiting ``UnsafeExprSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
-  @_spi(ExperimentalLanguageFeatures)
   open func visit(_ node: UnsafeExprSyntax) -> SyntaxVisitorContinueKind {
     return .visitChildren
   }
 
-  /// The function called after visiting `UnsafeExprSyntax` and its descendants.
+  /// The function called after visiting ``UnsafeExprSyntax`` and its descendants.
   ///   - node: the node we just finished visiting.
-  @_spi(ExperimentalLanguageFeatures)
   open func visitPost(_ node: UnsafeExprSyntax) {
   }
 

Sources/SwiftSyntax/generated/raw/RawSyntaxNodesTUVWXYZ.swift

@@ -1951,7 +1951,6 @@ public struct RawUnresolvedTernaryExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
-@_spi(ExperimentalLanguageFeatures)
 @_spi(RawSyntax)
 public struct RawUnsafeExprSyntax: RawExprSyntaxNodeProtocol {
   @_spi(RawSyntax)

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift

@@ -2841,7 +2841,6 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax
     }
   }
 
-  @_spi(ExperimentalLanguageFeatures)
   public var unexpectedBetweenAwaitKeywordAndUnsafeKeyword: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
@@ -2854,7 +2853,6 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax
   /// ### Tokens
   /// 
   /// For syntax trees generated by the parser, this is guaranteed to be `unsafe`.
-  @_spi(ExperimentalLanguageFeatures)
   public var unsafeKeyword: TokenSyntax? {
     get {
       return Syntax(self).child(at: 7)?.cast(TokenSyntax.self)
@@ -2864,7 +2862,6 @@ public struct ForStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStmtSyntax
     }
   }
 
-  @_spi(ExperimentalLanguageFeatures)
   public var unexpectedBetweenUnsafeKeywordAndCaseKeyword: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesTUVWXYZ.swift

@@ -3272,13 +3272,10 @@ public struct UnresolvedTernaryExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _
 
 // MARK: - UnsafeExprSyntax
 
-/// - Note: Requires experimental feature `unsafeExpression`.
-///
 /// ### Children
 /// 
 ///  - `unsafeKeyword`: `unsafe`
 ///  - `expression`: ``ExprSyntax``
-@_spi(ExperimentalLanguageFeatures)
 public struct UnsafeExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2194,31 +2194,17 @@ final class StatementExpressionTests: ParserTestCase {
       func f() {
         let x = unsafe y
       }
-      """,
-      experimentalFeatures: .unsafeExpression
+      """
     )
 
     assertParse(
       """
       func f() {
-        let x = unsafe1️⃣ y
+        let x = unsafe
+        y
       }
       """,
-      diagnostics: [
-        DiagnosticSpec(
-          message: "consecutive statements on a line must be separated by newline or ';'",
-          fixIts: [
-            "insert newline",
-            "insert ';'",
-          ]
-        )
-      ],
-      fixedSource: """
-        func f() {
-          let x = unsafe
-          y
-        }
-        """
+      substructure: DeclReferenceExprSyntax(baseName: .identifier("unsafe"))
     )
   }
 

Tests/SwiftParserTest/StatementTests.swift

@@ -960,23 +960,19 @@ final class StatementTests: ParserTestCase {
 
   func testForUnsafeStatement() {
     assertParse(
-      "for try await unsafe x in e { }",
-      experimentalFeatures: [.unsafeExpression]
+      "for try await unsafe x in e { }"
     )
 
     assertParse(
-      "for try await unsafe in e { }",
-      experimentalFeatures: [.unsafeExpression]
+      "for try await unsafe in e { }"
     )
 
     assertParse(
-      "for unsafe in e { }",
-      experimentalFeatures: [.unsafeExpression]
+      "for unsafe in e { }"
     )
 
     assertParse(
-      "for unsafe: Int in e { }",
-      experimentalFeatures: [.unsafeExpression]
+      "for unsafe: Int in e { }"
     )
   }
 }