Parse unsafe expression

Author: DougGregor

Sources/SwiftOperators/OperatorTable+Folding.swift

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #if compiler(>=6)
-public import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) public import SwiftSyntax
 #else
-import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 #endif
 
 extension ExprSyntax {
@@ -104,8 +104,8 @@ extension OperatorTable {
     op: ExprSyntax,
     rhs: ExprSyntax
   ) -> ExprSyntax {
-    // If the left-hand side is a "try" or "await", hoist it up to encompass
-    // the right-hand side as well.
+    // If the left-hand side is a "try", "await", or "unsafe", hoist it up to
+    // encompass the right-hand side as well.
     if let tryExpr = lhs.as(TryExprSyntax.self) {
       return ExprSyntax(
         TryExprSyntax(
@@ -138,6 +138,24 @@ extension OperatorTable {
       )
     }
 
+    if let unsafeExpr = lhs.as(UnsafeExprSyntax.self) {
+      return ExprSyntax(
+        UnsafeExprSyntax(
+          leadingTrivia: unsafeExpr.leadingTrivia,
+          unsafeExpr.unexpectedBeforeUnsafeKeyword,
+          unsafeKeyword: unsafeExpr.unsafeKeyword,
+          unsafeExpr.unexpectedBetweenUnsafeKeywordAndExpression,
+          expression: makeBinaryOperationExpr(
+            lhs: unsafeExpr.expression,
+            op: op,
+            rhs: rhs
+          ),
+          unsafeExpr.unexpectedAfterExpression,
+          trailingTrivia: unsafeExpr.trailingTrivia
+        )
+      )
+    }
+
     // The form of the binary operation depends on the operator itself,
     // which will be one of the unresolved infix operators.
 

Sources/SwiftParser/Expressions.swift

@@ -444,6 +444,19 @@ extension Parser {
           arena: self.arena
         )
       )
+    case (.unsafe, let handle)?:
+      let unsafeTok = self.eat(handle)
+      let sub = self.parseSequenceExpressionElement(
+        flavor: flavor,
+        pattern: pattern
+      )
+      return RawExprSyntax(
+        RawUnsafeExprSyntax(
+          unsafeKeyword: unsafeTok,
+          expression: sub,
+          arena: self.arena
+        )
+      )
     case (._move, let handle)?:
       let moveKeyword = self.eat(handle)
       let sub = self.parseSequenceExpressionElement(

Sources/SwiftParser/TokenSpecSet.swift

@@ -700,6 +700,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
   case `repeat`
   case each
   case any
+  case unsafe
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
     switch PrepareForKeywordMatch(lexeme) {
@@ -713,6 +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
     default: return nil
     }
   }
@@ -729,6 +731,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
     case .repeat: return .keyword(.repeat)
     case .each: return .keyword(.each)
     case .any: return .keyword(.any)
+    case .unsafe: return .keyword(.unsafe)
     }
   }
 }

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2188,6 +2188,40 @@ final class StatementExpressionTests: ParserTestCase {
     )
   }
 
+  func testUnsafeExpr() {
+    assertParse(
+      """
+      func f() {
+        let x = unsafe y
+      }
+      """,
+      experimentalFeatures: .unsafeExpression
+    )
+
+    assertParse(
+      """
+      func f() {
+        let x = unsafe1️⃣ 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
+      }
+      """
+    )
+  }
+
   func testUnterminatedInterpolationAtEndOfMultilineStringLiteral() {
     assertParse(
       #"""