Merge pull request #2937 from DougGregor/unsafe-expression

Author: DougGregor

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -21,6 +21,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case coroutineAccessors
   case valueGenerics
   case abiAttribute
+  case unsafeExpression
 
   /// The name of the feature as it is written in the compiler's `Features.def` file.
   public var featureName: String {
@@ -41,6 +42,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "ValueGenerics"
     case .abiAttribute:
       return "ABIAttribute"
+    case .unsafeExpression:
+      return "WarnUnsafe"
     }
   }
 
@@ -63,6 +66,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "value generics"
     case .abiAttribute:
       return "@abi attribute"
+    case .unsafeExpression:
+      return "'unsafe' expression"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -180,6 +180,23 @@ public let EXPR_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .unsafeExpr,
+    base: .expr,
+    experimentalFeature: .unsafeExpression,
+    nameForDiagnostics: "'unsafe' expression",
+    children: [
+      Child(
+        name: "unsafeKeyword",
+        kind: .token(choices: [.keyword(.unsafe)])
+      ),
+      Child(
+        name: "expression",
+        kind: .node(kind: .expr)
+      ),
+    ]
+  ),
+
   Node(
     kind: .binaryOperatorExpr,
     base: .expr,

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -299,6 +299,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case unresolvedAsExpr
   case unresolvedIsExpr
   case unresolvedTernaryExpr
+  case unsafeExpr
   case valueBindingPattern
   case variableDecl
   case versionComponent

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)
     }
   }
 }

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)
   }