Add support for @Lifetime(borrow ...)

Author: meg-gupta

CodeGeneration/Sources/SyntaxSupport/ExprNodes.swift

@@ -228,7 +228,7 @@ public let EXPR_NODES: [Node] = [
     children: [
       Child(
         name: "borrowKeyword",
-        kind: .token(choices: [.keyword(._borrow)])
+        kind: .token(choices: [.keyword(._borrow), .keyword(.borrow)])
       ),
       Child(
         name: "expression",

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -150,6 +150,7 @@ public enum Keyword: CaseIterable {
   case backDeployed
   case before
   case block
+  case borrow
   case borrowing
   case `break`
   case canImport
@@ -442,6 +443,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("before")
     case .block:
       return KeywordSpec("block")
+    case .borrow:
+      return KeywordSpec("borrow")
     case .borrowing:
       return KeywordSpec("borrowing")
     case .break:

Sources/SwiftParser/Expressions.swift

@@ -458,6 +458,11 @@ extension Parser {
         )
       )
     case (._borrow, let handle)?:
+      fallthrough
+    case (.borrow, let handle)?:
+      if !atContextualExpressionModifier() {
+        break EXPR_PREFIX
+      }
       let borrowTok = self.eat(handle)
       let sub = self.parseSequenceExpressionElement(
         flavor: flavor,

Sources/SwiftParser/TokenPrecedence.swift

@@ -235,7 +235,7 @@ enum TokenPrecedence: Comparable {
       .__consuming, .final, .required, .optional, .lazy, .dynamic, .infix, .postfix, .prefix, .mutating, .nonmutating,
       .convenience, .override, .package, .open,
       .__setter_access, .indirect, .isolated, .nonisolated, .distributed, ._local,
-      .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume,
+      .inout, ._mutating, ._borrow, ._borrowing, .borrow, .borrowing, ._consuming, .consuming, .consume,
       .dependsOn, .scoped, .sending,
       // Accessors
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,

Sources/SwiftParser/TokenSpecSet.swift

@@ -694,6 +694,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
   case _move
   case _borrow
   case `try`
+  case borrow
   case consume
   case copy
   case `repeat`
@@ -706,6 +707,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
     case TokenSpec(._move): self = ._move
     case TokenSpec(._borrow): self = ._borrow
     case TokenSpec(.try): self = .try
+    case TokenSpec(.borrow): self = .borrow
     case TokenSpec(.consume): self = .consume
     case TokenSpec(.copy): self = .copy
     case TokenSpec(.repeat): self = .repeat
@@ -720,6 +722,7 @@ enum ExpressionModifierKeyword: TokenSpecSet {
     case .await: return .keyword(.await)
     case ._move: return .keyword(._move)
     case ._borrow: return .keyword(._borrow)
+    case .borrow: return .keyword(.borrow)
     case .consume: return .keyword(.consume)
     case .copy: return .keyword(.copy)
     case .try: return .keyword(.try)

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -428,6 +428,58 @@ extension BooleanLiteralExprSyntax {
   }
 }
 
+extension BorrowExprSyntax {
+  @_spi(Diagnostics)
+  public enum BorrowKeywordOptions: TokenSpecSet {
+    case _borrow
+    case borrow
+
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(._borrow):
+        self = ._borrow
+      case TokenSpec(.borrow):
+        self = .borrow
+      default:
+        return nil
+      }
+    }
+
+    public init?(token: TokenSyntax) {
+      switch token {
+      case TokenSpec(._borrow):
+        self = ._borrow
+      case TokenSpec(.borrow):
+        self = .borrow
+      default:
+        return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case ._borrow:
+        return .keyword(._borrow)
+      case .borrow:
+        return .keyword(.borrow)
+      }
+    }
+
+    /// Returns a token that satisfies the `TokenSpec` of this case.
+    ///
+    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
+    @_spi(Diagnostics)
+    public var tokenSyntax: TokenSyntax {
+      switch self {
+      case ._borrow:
+        return .keyword(._borrow)
+      case .borrow:
+        return .keyword(.borrow)
+      }
+    }
+  }
+}
+
 extension _CanImportVersionInfoSyntax {
   @_spi(Diagnostics)
   public enum LabelOptions: TokenSpecSet {

Sources/SwiftSyntax/generated/Keyword.swift

@@ -90,6 +90,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case backDeployed
   case before
   case block
+  case borrow
   case borrowing
   case `break`
   case canImport
@@ -416,6 +417,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
         self = ._local
       case "before":
         self = .before
+      case "borrow":
+        self = .borrow
       case "deinit":
         self = .deinit
       case "didSet":
@@ -890,6 +893,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
     "backDeployed",
     "before",
     "block",
+    "borrow",
     "borrowing",
     "break",
     "canImport",

Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift

@@ -455,7 +455,7 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
   case .borrowExpr:
     assert(layout.count == 5)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("_borrow")]))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("_borrow"), .keyword("borrow")]))
     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))

Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift

@@ -4497,7 +4497,7 @@ public struct BooleanLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea
 
 /// ### Children
 /// 
-///  - `borrowKeyword`: `_borrow`
+///  - `borrowKeyword`: (`_borrow` | `borrow`)
 ///  - `expression`: ``ExprSyntax``
 public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
@@ -4515,7 +4515,7 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn
   public init(
     leadingTrivia: Trivia? = nil,
     _ unexpectedBeforeBorrowKeyword: UnexpectedNodesSyntax? = nil,
-    borrowKeyword: TokenSyntax = .keyword(._borrow),
+    borrowKeyword: TokenSyntax,
     _ unexpectedBetweenBorrowKeywordAndExpression: UnexpectedNodesSyntax? = nil,
     expression: some ExprSyntaxProtocol,
     _ unexpectedAfterExpression: UnexpectedNodesSyntax? = nil,
@@ -4559,7 +4559,9 @@ public struct BorrowExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _LeafExprSyn
 
   /// ### Tokens
   /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be `_borrow`.
+  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
+  ///  - `_borrow`
+  ///  - `borrow`
   public var borrowKeyword: TokenSyntax {
     get {
       return Syntax(self).child(at: 1)!.cast(TokenSyntax.self)

Tests/SwiftParserTest/AttributeTests.swift

@@ -1053,4 +1053,30 @@ final class AttributeTests: ParserTestCase {
         """
     )
   }
+
+  func testLifetimeAttribute() {
+    assertParse(
+      """
+      struct NE: ~Escapable {}
+
+      @lifetime(ne)
+      func derive1(ne: NE) -> NE { ne }
+
+      @lifetime(borrow ne)
+      func derive2(ne: borrowing NE) -> NE { ne }
+
+      @lifetime(ne1, n2)
+      func derive3(ne1: NE, ne2: NE) -> NE { ne1 }
+
+      @lifetime(borrow ne1, n2)
+      func derive4(ne1: NE, ne2: NE) -> NE { ne1 }
+
+      @lifetime(neOut: ne)
+      func derive5(ne: NE, neOut: inout NE) -> NE { neOut = ne }
+
+      @lifetime(neOut: borrow ne)
+      func derive6(ne: borrowing NE, neOut: inout NE) -> NE { neOut = ne }
+      """
+    )
+  }
 }