diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
index 895411bace0..eaff61fad2f 100644
--- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
@@ -108,9 +108,7 @@ public enum Keyword: CaseIterable {
   case _Class
   case _compilerInitialized
   case _const
-  case _consume
   case _consuming
-  case _copy
   case _documentation
   case _dynamicReplacement
   case _effects
@@ -121,7 +119,6 @@ public enum Keyword: CaseIterable {
   case _local
   case _modify
   case _move
-  case _mutate
   case _mutating
   case _NativeClass
   case _NativeRefCountedObject
@@ -186,6 +183,7 @@ public enum Keyword: CaseIterable {
   case `default`
   case `defer`
   case `deinit`
+  case dependsOn
   case deprecated
   case derivative
   case didSet
@@ -275,6 +273,7 @@ public enum Keyword: CaseIterable {
   case reverse
   case right
   case safe
+  case scoped
   case `self`
   case `Self`
   case Sendable
@@ -343,12 +342,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("_compilerInitialized")
     case ._const:
       return KeywordSpec("_const")
-    case ._consume:
-      return KeywordSpec("_consume", experimentalFeature: .nonescapableTypes)
     case ._consuming:
       return KeywordSpec("_consuming", experimentalFeature: .referenceBindings)
-    case ._copy:
-      return KeywordSpec("_copy", experimentalFeature: .nonescapableTypes)
     case ._documentation:
       return KeywordSpec("_documentation")
     case ._dynamicReplacement:
@@ -369,8 +364,6 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("_modify")
     case ._move:
       return KeywordSpec("_move")
-    case ._mutate:
-      return KeywordSpec("_mutate", experimentalFeature: .nonescapableTypes)
     case ._mutating:
       return KeywordSpec("_mutating", experimentalFeature: .referenceBindings)
     case ._NativeClass:
@@ -499,6 +492,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("defer", isLexerClassified: true)
     case .deinit:
       return KeywordSpec("deinit", isLexerClassified: true)
+    case .dependsOn:
+      return KeywordSpec("dependsOn", experimentalFeature: .nonescapableTypes)
     case .deprecated:
       return KeywordSpec("deprecated")
     case .derivative:
@@ -675,6 +670,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("right")
     case .safe:
       return KeywordSpec("safe")
+    case .scoped:
+      return KeywordSpec("scoped", experimentalFeature: .nonescapableTypes)
     case .self:
       return KeywordSpec("self", isLexerClassified: true)
     case .Self:
diff --git a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift
index f337aa226f3..f89ddb531d9 100644
--- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift
@@ -543,30 +543,30 @@ public let TYPE_NODES: [Node] = [
   ),
 
   Node(
-    kind: .lifetimeSpecifierArguments,
+    kind: .lifetimeTypeSpecifier,
     base: .syntax,
     experimentalFeature: .nonescapableTypes,
-    nameForDiagnostics: nil,
-    documentation: """
-      An optional argument passed to a type parameter.
-
-      ### Example
-      `borrow(data)` in `func foo(data: Array<Item>) -> borrow(data) ComplexReferenceType`
-      """,
-    traits: [
-      "Parenthesized"
-    ],
+    nameForDiagnostics: "lifetime specifier",
+    documentation: "A specifier that specifies function parameter on whose lifetime a type depends",
     children: [
+      Child(
+        name: "dependsOnKeyword",
+        kind: .token(choices: [.keyword(.dependsOn)]),
+        documentation: "lifetime dependence specifier on the return type"
+      ),
       Child(
         name: "leftParen",
         kind: .token(choices: [.token(.leftParen)])
       ),
+      Child(
+        name: "scopedKeyword",
+        kind: .token(choices: [.keyword(.scoped)]),
+        documentation: "lifetime of return value is scoped to the lifetime of the original value",
+        isOptional: true
+      ),
       Child(
         name: "arguments",
-        kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments"),
-        documentation: """
-          The function parameters that the lifetime of the annotated type depends on.
-          """
+        kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments")
       ),
       Child(
         name: "rightParen",
@@ -575,30 +575,6 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
-  Node(
-    kind: .lifetimeTypeSpecifier,
-    base: .syntax,
-    experimentalFeature: .nonescapableTypes,
-    nameForDiagnostics: "lifetime specifier",
-    documentation: "A specifier that specifies function parameter on whose lifetime a type depends",
-    children: [
-      Child(
-        name: "specifier",
-        kind: .token(choices: [
-          .keyword(._copy),
-          .keyword(._consume),
-          .keyword(._borrow),
-          .keyword(._mutate),
-        ]),
-        documentation: "The specifier token that's attached to the type."
-      ),
-      Child(
-        name: "arguments",
-        kind: .node(kind: .lifetimeSpecifierArguments)
-      ),
-    ]
-  ),
-
   Node(
     kind: .simpleTypeSpecifier,
     base: .syntax,
diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
index 49028b06247..0decc847b3a 100644
--- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
+++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
@@ -550,6 +550,7 @@ class ValidateSyntaxNodes: XCTestCase {
           node: .yieldedExpressionsClause,
           message: "could conform to trait 'Parenthesized' but does not"
         ),
+        ValidationFailure(node: .lifetimeTypeSpecifier, message: "could conform to trait 'Parenthesized' but does not"),
       ]
     )
   }
diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift
index a7e66423ba2..f61d51c1902 100644
--- a/Sources/SwiftParser/TokenPrecedence.swift
+++ b/Sources/SwiftParser/TokenPrecedence.swift
@@ -233,7 +233,7 @@ enum TokenPrecedence: Comparable {
       .__setter_access, .indirect, .isolated, .nonisolated, .distributed, ._local,
       .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume, ._resultDependsOnSelf,
       ._resultDependsOn,
-      .transferring, ._consume, ._copy, ._mutate,
+      .transferring, .dependsOn, .scoped,
       // Accessors
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,
       .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, ._modify,
diff --git a/Sources/SwiftParser/Types.swift b/Sources/SwiftParser/Types.swift
index 1ba26ee569d..0c1102dabf2 100644
--- a/Sources/SwiftParser/Types.swift
+++ b/Sources/SwiftParser/Types.swift
@@ -900,33 +900,31 @@ extension Parser.Lookahead {
 }
 
 extension Parser {
-  private mutating func parseLifetimeTypeSpecifier(
-    specifierHandle: TokenConsumptionHandle
-  ) -> RawTypeSpecifierListSyntax.Element {
-    let specifier = self.eat(specifierHandle)
+  private mutating func parseLifetimeTypeSpecifier() -> RawTypeSpecifierListSyntax.Element {
+    let (unexpectedBeforeDependsOnKeyword, dependsOnKeyword) = self.expect(.keyword(.dependsOn))
 
     guard let leftParen = self.consume(if: .leftParen) else {
       // If there is no left paren, add an entirely missing detail. Otherwise, we start to consume the following type
       // name as a token inside the detail, which leads to confusing recovery results.
-      let arguments = RawLifetimeSpecifierArgumentsSyntax(
-        leftParen: missingToken(.leftParen),
-        arguments: RawLifetimeSpecifierArgumentListSyntax(
-          elements: [
-            RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena)
-          ],
-          arena: self.arena
-        ),
-        rightParen: missingToken(.rightParen),
+      let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(
+        elements: [
+          RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena)
+        ],
         arena: self.arena
       )
       let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-        specifier: specifier,
-        arguments: arguments,
+        unexpectedBeforeDependsOnKeyword,
+        dependsOnKeyword: dependsOnKeyword,
+        leftParen: missingToken(.leftParen),
+        scopedKeyword: nil,
+        arguments: lifetimeSpecifierArgumentList,
+        rightParen: missingToken(.rightParen),
         arena: self.arena
       )
       return .lifetimeTypeSpecifier(lifetimeSpecifier)
     }
 
+    let scoped = self.consume(if: .keyword(.scoped))
     var keepGoing: RawTokenSyntax?
     var arguments: [RawLifetimeSpecifierArgumentSyntax] = []
     var loopProgress = LoopProgressCondition()
@@ -947,18 +945,16 @@ extension Parser {
     } while keepGoing != nil && self.hasProgressed(&loopProgress)
     let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(elements: arguments, arena: self.arena)
     let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-    let argumentsSyntax = RawLifetimeSpecifierArgumentsSyntax(
+    let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
+      unexpectedBeforeDependsOnKeyword,
+      dependsOnKeyword: dependsOnKeyword,
       leftParen: leftParen,
+      scopedKeyword: scoped,
       arguments: lifetimeSpecifierArgumentList,
       unexpectedBeforeRightParen,
       rightParen: rightParen,
       arena: self.arena
     )
-    let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-      specifier: specifier,
-      arguments: argumentsSyntax,
-      arena: self.arena
-    )
     return .lifetimeTypeSpecifier(lifetimeSpecifier)
   }
 
@@ -976,20 +972,18 @@ extension Parser {
     specifiers: RawTypeSpecifierListSyntax,
     attributes: RawAttributeListSyntax
   )? {
-    typealias SimpleOrLifetimeSpecifier =
-      EitherTokenSpecSet<SimpleTypeSpecifierSyntax.SpecifierOptions, LifetimeTypeSpecifierSyntax.SpecifierOptions>
     var specifiers: [RawTypeSpecifierListSyntax.Element] = []
-    SPECIFIER_PARSING: while canHaveParameterSpecifier,
-      let (specifierSpec, specifierHandle) = self.at(anyIn: SimpleOrLifetimeSpecifier.self)
-    {
-      switch specifierSpec {
-      case .lhs: specifiers.append(parseSimpleTypeSpecifier(specifierHandle: specifierHandle))
-      case .rhs:
+    SPECIFIER_PARSING: while canHaveParameterSpecifier {
+      if let (_, specifierHandle) = self.at(anyIn: SimpleTypeSpecifierSyntax.SpecifierOptions.self) {
+        specifiers.append(parseSimpleTypeSpecifier(specifierHandle: specifierHandle))
+      } else if self.at(.keyword(.dependsOn)) {
         if self.experimentalFeatures.contains(.nonescapableTypes) {
-          specifiers.append(parseLifetimeTypeSpecifier(specifierHandle: specifierHandle))
+          specifiers.append(parseLifetimeTypeSpecifier())
         } else {
           break SPECIFIER_PARSING
         }
+      } else {
+        break SPECIFIER_PARSING
       }
     }
     specifiers += misplacedSpecifiers.map {
diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
index 98c91c193d4..2667d7dd55f 100644
--- a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
+++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
@@ -2623,79 +2623,6 @@ extension LifetimeSpecifierArgumentSyntax {
   }
 }
 
-extension LifetimeTypeSpecifierSyntax {
-  @_spi(Diagnostics)
-  public enum SpecifierOptions: TokenSpecSet {
-    @_spi(ExperimentalLanguageFeatures)
-    case _copy
-    @_spi(ExperimentalLanguageFeatures)
-    case _consume
-    case _borrow
-    @_spi(ExperimentalLanguageFeatures)
-    case _mutate
-    
-    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(._copy) where experimentalFeatures.contains(.nonescapableTypes):
-        self = ._copy
-      case TokenSpec(._consume) where experimentalFeatures.contains(.nonescapableTypes):
-        self = ._consume
-      case TokenSpec(._borrow):
-        self = ._borrow
-      case TokenSpec(._mutate) where experimentalFeatures.contains(.nonescapableTypes):
-        self = ._mutate
-      default:
-        return nil
-      }
-    }
-    
-    public init?(token: TokenSyntax) {
-      switch token {
-      case TokenSpec(._copy):
-        self = ._copy
-      case TokenSpec(._consume):
-        self = ._consume
-      case TokenSpec(._borrow):
-        self = ._borrow
-      case TokenSpec(._mutate):
-        self = ._mutate
-      default:
-        return nil
-      }
-    }
-    
-    var spec: TokenSpec {
-      switch self {
-      case ._copy:
-        return .keyword(._copy)
-      case ._consume:
-        return .keyword(._consume)
-      case ._borrow:
-        return .keyword(._borrow)
-      case ._mutate:
-        return .keyword(._mutate)
-      }
-    }
-    
-    /// 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 ._copy:
-        return .keyword(._copy)
-      case ._consume:
-        return .keyword(._consume)
-      case ._borrow:
-        return .keyword(._borrow)
-      case ._mutate:
-        return .keyword(._mutate)
-      }
-    }
-  }
-}
-
 extension MemberTypeSyntax {
   @_spi(Diagnostics)
   public enum NameOptions: TokenSpecSet {
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
index a738f6b9979..adec42bc2ca 100644
--- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
+++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -2009,30 +2009,28 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \LifetimeSpecifierArgumentSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeLeftParen:
-    return "unexpectedBeforeLeftParen"
-  case \LifetimeSpecifierArgumentsSyntax.leftParen:
+  case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword:
+    return "unexpectedBeforeDependsOnKeyword"
+  case \LifetimeTypeSpecifierSyntax.dependsOnKeyword:
+    return "dependsOnKeyword"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenDependsOnKeywordAndLeftParen:
+    return "unexpectedBetweenDependsOnKeywordAndLeftParen"
+  case \LifetimeTypeSpecifierSyntax.leftParen:
     return "leftParen"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenLeftParenAndArguments:
-    return "unexpectedBetweenLeftParenAndArguments"
-  case \LifetimeSpecifierArgumentsSyntax.arguments:
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScopedKeyword:
+    return "unexpectedBetweenLeftParenAndScopedKeyword"
+  case \LifetimeTypeSpecifierSyntax.scopedKeyword:
+    return "scopedKeyword"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedKeywordAndArguments:
+    return "unexpectedBetweenScopedKeywordAndArguments"
+  case \LifetimeTypeSpecifierSyntax.arguments:
     return "arguments"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenArgumentsAndRightParen:
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenArgumentsAndRightParen:
     return "unexpectedBetweenArgumentsAndRightParen"
-  case \LifetimeSpecifierArgumentsSyntax.rightParen:
+  case \LifetimeTypeSpecifierSyntax.rightParen:
     return "rightParen"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterRightParen:
+  case \LifetimeTypeSpecifierSyntax.unexpectedAfterRightParen:
     return "unexpectedAfterRightParen"
-  case \LifetimeTypeSpecifierSyntax.unexpectedBeforeSpecifier:
-    return "unexpectedBeforeSpecifier"
-  case \LifetimeTypeSpecifierSyntax.specifier:
-    return "specifier"
-  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenSpecifierAndArguments:
-    return "unexpectedBetweenSpecifierAndArguments"
-  case \LifetimeTypeSpecifierSyntax.arguments:
-    return "arguments"
-  case \LifetimeTypeSpecifierSyntax.unexpectedAfterArguments:
-    return "unexpectedAfterArguments"
   case \MacroDeclSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
   case \MacroDeclSyntax.attributes:
diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift
index c331f2f5716..d38e92e96f6 100644
--- a/Sources/SwiftSyntax/generated/Keyword.swift
+++ b/Sources/SwiftSyntax/generated/Keyword.swift
@@ -28,11 +28,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case _compilerInitialized
   case _const
   @_spi(ExperimentalLanguageFeatures)
-  case _consume
-  @_spi(ExperimentalLanguageFeatures)
   case _consuming
-  @_spi(ExperimentalLanguageFeatures)
-  case _copy
   case _documentation
   case _dynamicReplacement
   case _effects
@@ -44,8 +40,6 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case _modify
   case _move
   @_spi(ExperimentalLanguageFeatures)
-  case _mutate
-  @_spi(ExperimentalLanguageFeatures)
   case _mutating
   case _NativeClass
   case _NativeRefCountedObject
@@ -110,6 +104,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case `default`
   case `defer`
   case `deinit`
+  @_spi(ExperimentalLanguageFeatures)
+  case dependsOn
   case deprecated
   case derivative
   case didSet
@@ -201,6 +197,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case reverse
   case right
   case safe
+  @_spi(ExperimentalLanguageFeatures)
+  case scoped
   case `self`
   case `Self`
   case Sendable
@@ -343,8 +341,6 @@ public enum Keyword: UInt8, Hashable, Sendable {
       }
     case 5:
       switch text {
-      case "_copy":
-        self = ._copy
       case "_move":
         self = ._move
       case "_read":
@@ -428,6 +424,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
         self = .repeat
       case "return":
         self = .return
+      case "scoped":
+        self = .scoped
       case "static":
         self = .static
       case "struct":
@@ -455,8 +453,6 @@ public enum Keyword: UInt8, Hashable, Sendable {
         self = ._linear
       case "_modify":
         self = ._modify
-      case "_mutate":
-        self = ._mutate
       case "consume":
         self = .consume
       case "default":
@@ -494,8 +490,6 @@ public enum Keyword: UInt8, Hashable, Sendable {
       switch text {
       case "__shared":
         self = .__shared
-      case "_consume":
-        self = ._consume
       case "_effects":
         self = ._effects
       case "_forward":
@@ -563,6 +557,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
         self = .canImport
       case "consuming":
         self = .consuming
+      case "dependsOn":
+        self = .dependsOn
       case "extension":
         self = .extension
       case "lowerThan":
@@ -826,9 +822,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
       "_Class", 
       "_compilerInitialized", 
       "_const", 
-      "_consume", 
       "_consuming", 
-      "_copy", 
       "_documentation", 
       "_dynamicReplacement", 
       "_effects", 
@@ -839,7 +833,6 @@ public enum Keyword: UInt8, Hashable, Sendable {
       "_local", 
       "_modify", 
       "_move", 
-      "_mutate", 
       "_mutating", 
       "_NativeClass", 
       "_NativeRefCountedObject", 
@@ -904,6 +897,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
       "default", 
       "defer", 
       "deinit", 
+      "dependsOn", 
       "deprecated", 
       "derivative", 
       "didSet", 
@@ -993,6 +987,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
       "reverse", 
       "right", 
       "safe", 
+      "scoped", 
       "self", 
       "Self", 
       "Sendable", 
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
index 17eb0b51b3e..83bef83ebef 100644
--- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -1374,20 +1374,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
   
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
-  override open func visit(_ node: LifetimeSpecifierArgumentsSyntax) -> SyntaxVisitorContinueKind {
-    return visitAny(node._syntaxNode)
-  }
-  
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
-  override open func visitPost(_ node: LifetimeSpecifierArgumentsSyntax) {
-    visitAnyPost(node._syntaxNode)
-  }
-  
   #if compiler(>=5.8)
   @_spi(ExperimentalLanguageFeatures)
   #endif
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
index 7ff75ce92c4..e5cd0600dc2 100644
--- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -1681,7 +1681,6 @@ extension Syntax {
           .node(LayoutRequirementSyntax.self),
           .node(LifetimeSpecifierArgumentListSyntax.self),
           .node(LifetimeSpecifierArgumentSyntax.self),
-          .node(LifetimeSpecifierArgumentsSyntax.self),
           .node(LifetimeTypeSpecifierSyntax.self),
           .node(MacroDeclSyntax.self),
           .node(MacroExpansionDeclSyntax.self),
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
index cf24a56b678..0654f834647 100644
--- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -191,10 +191,6 @@ public enum SyntaxEnum: Sendable {
   #if compiler(>=5.8)
   @_spi(ExperimentalLanguageFeatures)
   #endif
-  case lifetimeSpecifierArguments(LifetimeSpecifierArgumentsSyntax)
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
   case lifetimeTypeSpecifier(LifetimeTypeSpecifierSyntax)
   case macroDecl(MacroDeclSyntax)
   case macroExpansionDecl(MacroExpansionDeclSyntax)
@@ -651,8 +647,6 @@ public extension Syntax {
       return .lifetimeSpecifierArgumentList(LifetimeSpecifierArgumentListSyntax(self)!)
     case .lifetimeSpecifierArgument:
       return .lifetimeSpecifierArgument(LifetimeSpecifierArgumentSyntax(self)!)
-    case .lifetimeSpecifierArguments:
-      return .lifetimeSpecifierArguments(LifetimeSpecifierArgumentsSyntax(self)!)
     case .lifetimeTypeSpecifier:
       return .lifetimeTypeSpecifier(LifetimeTypeSpecifierSyntax(self)!)
     case .macroDecl:
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
index 3724843f407..05829bf445b 100644
--- a/Sources/SwiftSyntax/generated/SyntaxKind.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -191,10 +191,6 @@ public enum SyntaxKind: Sendable {
   #if compiler(>=5.8)
   @_spi(ExperimentalLanguageFeatures)
   #endif
-  case lifetimeSpecifierArguments
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
   case lifetimeTypeSpecifier
   case macroDecl
   case macroExpansionDecl
@@ -776,8 +772,6 @@ public enum SyntaxKind: Sendable {
       return LifetimeSpecifierArgumentListSyntax.self
     case .lifetimeSpecifierArgument:
       return LifetimeSpecifierArgumentSyntax.self
-    case .lifetimeSpecifierArguments:
-      return LifetimeSpecifierArgumentsSyntax.self
     case .lifetimeTypeSpecifier:
       return LifetimeTypeSpecifierSyntax.self
     case .macroDecl:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
index e3b3b26d480..7a2bb82f013 100644
--- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -1225,16 +1225,6 @@ open class SyntaxRewriter {
     return visitChildren(node)
   }
   
-  /// Visit a `LifetimeSpecifierArgumentsSyntax`.
-  ///   - Parameter node: the node that is being visited
-  ///   - Returns: the rewritten node
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
-  open func visit(_ node: LifetimeSpecifierArgumentsSyntax) -> LifetimeSpecifierArgumentsSyntax {
-    return visitChildren(node)
-  }
-  
   /// Visit a `LifetimeTypeSpecifierSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2820,10 +2810,6 @@ open class SyntaxRewriter {
       return {
         self.visitImpl($0, LifetimeSpecifierArgumentSyntax.self, self.visit)
       }
-    case .lifetimeSpecifierArguments:
-      return {
-        self.visitImpl($0, LifetimeSpecifierArgumentsSyntax.self, self.visit)
-      }
     case .lifetimeTypeSpecifier:
       return {
         self.visitImpl($0, LifetimeTypeSpecifierSyntax.self, self.visit)
@@ -3642,8 +3628,6 @@ open class SyntaxRewriter {
       return visitImpl(node, LifetimeSpecifierArgumentListSyntax.self, visit)
     case .lifetimeSpecifierArgument:
       return visitImpl(node, LifetimeSpecifierArgumentSyntax.self, visit)
-    case .lifetimeSpecifierArguments:
-      return visitImpl(node, LifetimeSpecifierArgumentsSyntax.self, visit)
     case .lifetimeTypeSpecifier:
       return visitImpl(node, LifetimeTypeSpecifierSyntax.self, visit)
     case .macroDecl:
diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
index 83c8529f9a2..1034e136ffc 100644
--- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
@@ -779,8 +779,6 @@ extension LabeledSpecializeArgumentSyntax: WithTrailingCommaSyntax {}
 
 extension LifetimeSpecifierArgumentSyntax: WithTrailingCommaSyntax {}
 
-extension LifetimeSpecifierArgumentsSyntax: ParenthesizedSyntax {}
-
 extension MacroDeclSyntax: NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
 extension MacroExpansionDeclSyntax: FreestandingMacroExpansionSyntax, WithAttributesSyntax, WithModifiersSyntax {}
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
index 80a4de49214..4468b10c27b 100644
--- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -2019,24 +2019,6 @@ open class SyntaxVisitor {
   open func visitPost(_ node: LifetimeSpecifierArgumentSyntax) {
   }
   
-  /// Visiting `LifetimeSpecifierArgumentsSyntax` 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: LifetimeSpecifierArgumentsSyntax) -> SyntaxVisitorContinueKind {
-    return .visitChildren
-  }
-  
-  /// The function called after visiting `LifetimeSpecifierArgumentsSyntax` and its descendants.
-  ///   - node: the node we just finished visiting.
-  #if compiler(>=5.8)
-  @_spi(ExperimentalLanguageFeatures)
-  #endif
-  open func visitPost(_ node: LifetimeSpecifierArgumentsSyntax) {
-  }
-  
   /// Visiting `LifetimeTypeSpecifierSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4220,10 +4202,6 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, LifetimeSpecifierArgumentSyntax.self, self.visit, self.visitPost)
       }
-    case .lifetimeSpecifierArguments:
-      return {
-        self.visitImpl(&$0, LifetimeSpecifierArgumentsSyntax.self, self.visit, self.visitPost)
-      }
     case .lifetimeTypeSpecifier:
       return {
         self.visitImpl(&$0, LifetimeTypeSpecifierSyntax.self, self.visit, self.visitPost)
@@ -5046,8 +5024,6 @@ open class SyntaxVisitor {
       visitImpl(&node, LifetimeSpecifierArgumentListSyntax.self, visit, visitPost)
     case .lifetimeSpecifierArgument:
       visitImpl(&node, LifetimeSpecifierArgumentSyntax.self, visit, visitPost)
-    case .lifetimeSpecifierArguments:
-      visitImpl(&node, LifetimeSpecifierArgumentsSyntax.self, visit, visitPost)
     case .lifetimeTypeSpecifier:
       visitImpl(&node, LifetimeTypeSpecifierSyntax.self, visit, visitPost)
     case .macroDecl:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
index d5e9ab34c9d..18adc64115b 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
@@ -1053,14 +1053,14 @@ public struct RawLifetimeSpecifierArgumentSyntax: RawSyntaxNodeProtocol {
 @_spi(ExperimentalLanguageFeatures)
 #endif
 @_spi(RawSyntax)
-public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol {
+public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
   
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .lifetimeSpecifierArguments
+    return raw.kind == .lifetimeTypeSpecifier
   }
   
   public var raw: RawSyntax
@@ -1082,9 +1082,13 @@ public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public init(
-      _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? = nil, 
+      dependsOnKeyword: RawTokenSyntax, 
+      _ unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, 
       leftParen: RawTokenSyntax, 
-      _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? = nil, 
+      scopedKeyword: RawTokenSyntax?, 
+      _ unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? = nil, 
       arguments: RawLifetimeSpecifierArgumentListSyntax, 
       _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, 
       rightParen: RawTokenSyntax, 
@@ -1092,118 +1096,65 @@ public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol {
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .lifetimeSpecifierArguments, uninitializedCount: 7, arena: arena) { layout in
+      kind: .lifetimeTypeSpecifier, uninitializedCount: 11, arena: arena) { layout in
       layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeLeftParen?.raw
-      layout[1] = leftParen.raw
-      layout[2] = unexpectedBetweenLeftParenAndArguments?.raw
-      layout[3] = arguments.raw
-      layout[4] = unexpectedBetweenArgumentsAndRightParen?.raw
-      layout[5] = rightParen.raw
-      layout[6] = unexpectedAfterRightParen?.raw
+      layout[0] = unexpectedBeforeDependsOnKeyword?.raw
+      layout[1] = dependsOnKeyword.raw
+      layout[2] = unexpectedBetweenDependsOnKeywordAndLeftParen?.raw
+      layout[3] = leftParen.raw
+      layout[4] = unexpectedBetweenLeftParenAndScopedKeyword?.raw
+      layout[5] = scopedKeyword?.raw
+      layout[6] = unexpectedBetweenScopedKeywordAndArguments?.raw
+      layout[7] = arguments.raw
+      layout[8] = unexpectedBetweenArgumentsAndRightParen?.raw
+      layout[9] = rightParen.raw
+      layout[10] = unexpectedAfterRightParen?.raw
     }
     self.init(unchecked: raw)
   }
   
-  public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var leftParen: RawTokenSyntax {
+  public var dependsOnKeyword: RawTokenSyntax {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
-  public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var arguments: RawLifetimeSpecifierArgumentListSyntax {
-    layoutView.children[3].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))!
+  public var leftParen: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
-  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  public var scopedKeyword: RawTokenSyntax? {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
   }
   
-  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? {
     layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-}
-
-#if compiler(>=5.8)
-@_spi(ExperimentalLanguageFeatures)
-#endif
-@_spi(RawSyntax)
-public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol {
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-  
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .lifetimeTypeSpecifier
-  }
-  
-  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(
-      _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, 
-      specifier: RawTokenSyntax, 
-      _ unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? = nil, 
-      arguments: RawLifetimeSpecifierArgumentsSyntax, 
-      _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, 
-      arena: __shared SyntaxArena
-    ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .lifetimeTypeSpecifier, uninitializedCount: 5, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeSpecifier?.raw
-      layout[1] = specifier.raw
-      layout[2] = unexpectedBetweenSpecifierAndArguments?.raw
-      layout[3] = arguments.raw
-      layout[4] = unexpectedAfterArguments?.raw
-    }
-    self.init(unchecked: raw)
-  }
   
-  public var unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  
-  public var specifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
+  public var arguments: RawLifetimeSpecifierArgumentListSyntax {
+    layoutView.children[7].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))!
   }
   
-  public var unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var arguments: RawLifetimeSpecifierArgumentsSyntax {
-    layoutView.children[3].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))!
+  public var rightParen: RawTokenSyntax {
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
   }
   
-  public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
index 8d22721337f..31ef04df6dd 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -1725,27 +1725,19 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-  case .lifetimeSpecifierArguments:
-    assert(layout.count == 7)
-    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
-    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawLifetimeSpecifierArgumentListSyntax.self))
-    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
-    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
   case .lifetimeTypeSpecifier:
-    assert(layout.count == 5)
+    assert(layout.count == 11)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [
-            .keyword("_copy"), 
-            .keyword("_consume"), 
-            .keyword("_borrow"), 
-            .keyword("_mutate")
-          ]))
+    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.keyword("dependsOn")]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawLifetimeSpecifierArgumentsSyntax.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.keyword("scoped")]))
+    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 7, verify(layout[7], as: RawLifetimeSpecifierArgumentListSyntax.self))
+    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
+    assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
   case .macroDecl:
     assert(layout.count == 17)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
index 605ea5af339..9db4ef199ab 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
@@ -1790,28 +1790,31 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _
   }
 }
 
-// MARK: - LifetimeSpecifierArgumentsSyntax
+// MARK: - LifetimeTypeSpecifierSyntax
 
-/// An optional argument passed to a type parameter.
-/// 
-/// ### Example
-/// `borrow(data)` in `func foo(data: Array<Item>) -> borrow(data) ComplexReferenceType`
+/// A specifier that specifies function parameter on whose lifetime a type depends
 ///
 /// - Experiment: Requires experimental feature `nonescapableTypes`.
 ///
 /// ### Children
 /// 
+///  - `dependsOnKeyword`: `dependsOn`
 ///  - `leftParen`: `(`
+///  - `scopedKeyword`: `scoped`?
 ///  - `arguments`: `LifetimeSpecifierArgumentListSyntax`
 ///  - `rightParen`: `)`
+///
+/// ### Contained in
+/// 
+///  - ``TypeSpecifierListSyntax``
 #if compiler(>=5.8)
 @_spi(ExperimentalLanguageFeatures)
 #endif
-public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
+public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
   
   public init?(_ node: some SyntaxProtocol) {
-    guard node.raw.kind == .lifetimeSpecifierArguments else {
+    guard node.raw.kind == .lifetimeTypeSpecifier else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -1819,13 +1822,18 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   
   /// - Parameters:
   ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
-  ///   - arguments: The function parameters that the lifetime of the annotated type depends on.
+  ///   - dependsOnKeyword: lifetime dependence specifier on the return type
+  ///   - scopedKeyword: lifetime of return value is scoped to the lifetime of the original value
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
       leadingTrivia: Trivia? = nil,
-      _ unexpectedBeforeLeftParen: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? = nil,
+      dependsOnKeyword: TokenSyntax = .keyword(.dependsOn),
+      _ unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? = nil,
       leftParen: TokenSyntax = .leftParenToken(),
-      _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? = nil,
+      scopedKeyword: TokenSyntax? = nil,
+      _ unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? = nil,
       arguments: LifetimeSpecifierArgumentListSyntax,
       _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil,
       rightParen: TokenSyntax = .rightParenToken(),
@@ -1836,25 +1844,33 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     // Extend the lifetime of all parameters so their arenas don't get destroyed
     // before they can be added as children of the new arena.
     self = withExtendedLifetime((SyntaxArena(), (
-            unexpectedBeforeLeftParen, 
+            unexpectedBeforeDependsOnKeyword, 
+            dependsOnKeyword, 
+            unexpectedBetweenDependsOnKeywordAndLeftParen, 
             leftParen, 
-            unexpectedBetweenLeftParenAndArguments, 
+            unexpectedBetweenLeftParenAndScopedKeyword, 
+            scopedKeyword, 
+            unexpectedBetweenScopedKeywordAndArguments, 
             arguments, 
             unexpectedBetweenArgumentsAndRightParen, 
             rightParen, 
             unexpectedAfterRightParen
           ))) { (arena, _) in
       let layout: [RawSyntax?] = [
-          unexpectedBeforeLeftParen?.raw, 
+          unexpectedBeforeDependsOnKeyword?.raw, 
+          dependsOnKeyword.raw, 
+          unexpectedBetweenDependsOnKeywordAndLeftParen?.raw, 
           leftParen.raw, 
-          unexpectedBetweenLeftParenAndArguments?.raw, 
+          unexpectedBetweenLeftParenAndScopedKeyword?.raw, 
+          scopedKeyword?.raw, 
+          unexpectedBetweenScopedKeywordAndArguments?.raw, 
           arguments.raw, 
           unexpectedBetweenArgumentsAndRightParen?.raw, 
           rightParen.raw, 
           unexpectedAfterRightParen?.raw
         ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.lifetimeSpecifierArguments,
+        kind: SyntaxKind.lifetimeTypeSpecifier,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -1865,43 +1881,88 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     }
   }
   
-  public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? {
+  public var unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
+  /// lifetime dependence specifier on the return type
+  ///
   /// ### Tokens
   /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be `(`.
-  public var leftParen: TokenSyntax {
+  /// For syntax trees generated by the parser, this is guaranteed to be `dependsOn`.
+  public var dependsOnKeyword: TokenSyntax {
     get {
       return Syntax(self).child(at: 1)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
-  public var unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be `(`.
+  public var leftParen: TokenSyntax {
+    get {
+      return Syntax(self).child(at: 3)!.cast(TokenSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  public var unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  /// lifetime of return value is scoped to the lifetime of the original value
+  ///
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be `scoped`.
+  public var scopedKeyword: TokenSyntax? {
+    get {
+      return Syntax(self).child(at: 5)?.cast(TokenSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  public var unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
-  /// The function parameters that the lifetime of the annotated type depends on.
   public var arguments: LifetimeSpecifierArgumentListSyntax {
     get {
-      return Syntax(self).child(at: 3)!.cast(LifetimeSpecifierArgumentListSyntax.self)
+      return Syntax(self).child(at: 7)!.cast(LifetimeSpecifierArgumentListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
@@ -1913,10 +1974,10 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   /// - returns: A copy of the receiver with the provided `Arguments`
   ///            appended to its `arguments` collection.
   @available(*, deprecated, message: "Use node.arguments.append(newElement) instead")
-  public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeSpecifierArgumentsSyntax {
+  public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeTypeSpecifierSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
-    if let col = raw.layoutView!.children[3] {
+    if let col = raw.layoutView!.children[7] {
       collection = col.layoutView!.appending(element.raw, arena: arena)
     } else {
       collection = RawSyntax.makeLayout(kind: SyntaxKind.lifetimeSpecifierArgumentList,
@@ -1924,20 +1985,20 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     }
     return Syntax(self)
       .replacingChild(
-        at: 3, 
+        at: 7, 
         with: collection, 
         rawNodeArena: arena, 
         allocationArena: arena
       )
-      .cast(LifetimeSpecifierArgumentsSyntax.self)
+      .cast(LifetimeTypeSpecifierSyntax.self)
   }
   
   public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
@@ -1946,27 +2007,31 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   /// For syntax trees generated by the parser, this is guaranteed to be `)`.
   public var rightParen: TokenSyntax {
     get {
-      return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
+      return Syntax(self).child(at: 9)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
   public var unexpectedAfterRightParen: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
     }
   }
   
   public static var structure: SyntaxNodeStructure {
     return .layout([
-          \Self.unexpectedBeforeLeftParen, 
+          \Self.unexpectedBeforeDependsOnKeyword, 
+          \Self.dependsOnKeyword, 
+          \Self.unexpectedBetweenDependsOnKeywordAndLeftParen, 
           \Self.leftParen, 
-          \Self.unexpectedBetweenLeftParenAndArguments, 
+          \Self.unexpectedBetweenLeftParenAndScopedKeyword, 
+          \Self.scopedKeyword, 
+          \Self.unexpectedBetweenScopedKeywordAndArguments, 
           \Self.arguments, 
           \Self.unexpectedBetweenArgumentsAndRightParen, 
           \Self.rightParen, 
@@ -1975,140 +2040,6 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   }
 }
 
-// MARK: - LifetimeTypeSpecifierSyntax
-
-/// A specifier that specifies function parameter on whose lifetime a type depends
-///
-/// - Experiment: Requires experimental feature `nonescapableTypes`.
-///
-/// ### Children
-/// 
-///  - `specifier`: (`_copy` | `_consume` | `_borrow` | `_mutate`)
-///  - `arguments`: `LifetimeSpecifierArgumentsSyntax`
-///
-/// ### Contained in
-/// 
-///  - ``TypeSpecifierListSyntax``
-#if compiler(>=5.8)
-@_spi(ExperimentalLanguageFeatures)
-#endif
-public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
-  public let _syntaxNode: Syntax
-  
-  public init?(_ node: some SyntaxProtocol) {
-    guard node.raw.kind == .lifetimeTypeSpecifier else {
-      return nil
-    }
-    self._syntaxNode = node._syntaxNode
-  }
-  
-  /// - Parameters:
-  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
-  ///   - specifier: The specifier token that's attached to the type.
-  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
-  public init(
-      leadingTrivia: Trivia? = nil,
-      _ unexpectedBeforeSpecifier: UnexpectedNodesSyntax? = nil,
-      specifier: TokenSyntax,
-      _ unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? = nil,
-      arguments: LifetimeSpecifierArgumentsSyntax,
-      _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil,
-      trailingTrivia: Trivia? = nil
-    
-  ) {
-    // Extend the lifetime of all parameters so their arenas don't get destroyed
-    // before they can be added as children of the new arena.
-    self = withExtendedLifetime((SyntaxArena(), (
-            unexpectedBeforeSpecifier, 
-            specifier, 
-            unexpectedBetweenSpecifierAndArguments, 
-            arguments, 
-            unexpectedAfterArguments
-          ))) { (arena, _) in
-      let layout: [RawSyntax?] = [
-          unexpectedBeforeSpecifier?.raw, 
-          specifier.raw, 
-          unexpectedBetweenSpecifierAndArguments?.raw, 
-          arguments.raw, 
-          unexpectedAfterArguments?.raw
-        ]
-      let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.lifetimeTypeSpecifier,
-        from: layout,
-        arena: arena,
-        leadingTrivia: leadingTrivia,
-        trailingTrivia: trailingTrivia
-        
-      )
-      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
-    }
-  }
-  
-  public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? {
-    get {
-      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
-    }
-  }
-  
-  /// The specifier token that's attached to the type.
-  ///
-  /// ### Tokens
-  /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
-  ///  - `_copy`
-  ///  - `_consume`
-  ///  - `_borrow`
-  ///  - `_mutate`
-  public var specifier: TokenSyntax {
-    get {
-      return Syntax(self).child(at: 1)!.cast(TokenSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
-    }
-  }
-  
-  public var unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? {
-    get {
-      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
-    }
-  }
-  
-  public var arguments: LifetimeSpecifierArgumentsSyntax {
-    get {
-      return Syntax(self).child(at: 3)!.cast(LifetimeSpecifierArgumentsSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
-    }
-  }
-  
-  public var unexpectedAfterArguments: UnexpectedNodesSyntax? {
-    get {
-      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
-    }
-  }
-  
-  public static var structure: SyntaxNodeStructure {
-    return .layout([
-          \Self.unexpectedBeforeSpecifier, 
-          \Self.specifier, 
-          \Self.unexpectedBetweenSpecifierAndArguments, 
-          \Self.arguments, 
-          \Self.unexpectedAfterArguments
-        ])
-  }
-}
-
 // MARK: - MacroDeclSyntax
 
 /// ### Children
diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift
index 30ed2f2e096..19759906dcd 100644
--- a/Tests/SwiftParserTest/DeclarationTests.swift
+++ b/Tests/SwiftParserTest/DeclarationTests.swift
@@ -3286,7 +3286,7 @@ final class DeclarationTests: ParserTestCase {
 
   func testInitializerWithReturnType() {
     assertParse(
-      "init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array<Int>) -> _borrow(a) Self",
+      "init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array<Int>) -> dependsOn(a) Self",
       experimentalFeatures: .nonescapableTypes
     )
 
diff --git a/Tests/SwiftParserTest/TypeTests.swift b/Tests/SwiftParserTest/TypeTests.swift
index 936ef5f817a..5e5f503c5c3 100644
--- a/Tests/SwiftParserTest/TypeTests.swift
+++ b/Tests/SwiftParserTest/TypeTests.swift
@@ -331,12 +331,12 @@ final class TypeTests: ParserTestCase {
   }
 
   func testLifetimeSpecifier() {
-    assertParse("func foo() -> _borrow(x) X", experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(x) X", experimentalFeatures: [.nonescapableTypes])
 
-    assertParse("func foo() -> _borrow(x, y) X", experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(x, y) X", experimentalFeatures: [.nonescapableTypes])
 
     assertParse(
-      "func foo() -> _borrow(1️⃣) X",
+      "func foo() -> dependsOn(1️⃣) X",
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -344,12 +344,12 @@ final class TypeTests: ParserTestCase {
           fixIts: ["insert parameter reference"]
         )
       ],
-      fixedSource: "func foo() -> _borrow(<#identifier#>) X",
+      fixedSource: "func foo() -> dependsOn(<#identifier#>) X",
       experimentalFeatures: [.nonescapableTypes]
     )
 
     assertParse(
-      "func foo() -> _borrow(x,1️⃣) X",
+      "func foo() -> dependsOn(x,1️⃣) X",
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -357,20 +357,16 @@ final class TypeTests: ParserTestCase {
           fixIts: ["insert parameter reference"]
         )
       ],
-      fixedSource: "func foo() -> _borrow(x, <#identifier#>) X",
+      fixedSource: "func foo() -> dependsOn(x, <#identifier#>) X",
       experimentalFeatures: [.nonescapableTypes]
     )
 
-    assertParse("func foo() -> _borrow(x) _borrow(y) X", experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(x) dependsOn(scoped y) X", experimentalFeatures: [.nonescapableTypes])
 
-    assertParse("func foo() -> _mutate(x) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse("func foo() -> _copy(x) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse("func foo() -> _consume(x) X", experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(scoped x) X", experimentalFeatures: [.nonescapableTypes])
 
     assertParse(
-      "func foo() -> _borrow 1️⃣X",
+      "func foo() -> dependsOn 1️⃣X",
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -378,12 +374,12 @@ final class TypeTests: ParserTestCase {
           fixIts: ["insert '(', parameter reference, and ')'"]
         )
       ],
-      fixedSource: "func foo() -> _borrow (<#identifier#>) X",
+      fixedSource: "func foo() -> dependsOn (<#identifier#>) X",
       experimentalFeatures: [.nonescapableTypes]
     )
 
     assertParse(
-      "func foo() -> _borrow(1️⃣*) X",
+      "func foo() -> dependsOn(1️⃣*) X",
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -392,16 +388,16 @@ final class TypeTests: ParserTestCase {
         ),
         DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '*' in lifetime specifier"),
       ],
-      fixedSource: "func foo() -> _borrow(<#identifier#>*) X",
+      fixedSource: "func foo() -> dependsOn(<#identifier#>*) X",
       experimentalFeatures: [.nonescapableTypes]
     )
 
-    assertParse("func foo() -> _borrow(0) X", diagnostics: [], experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(0) X", diagnostics: [], experimentalFeatures: [.nonescapableTypes])
 
-    assertParse("func foo() -> _borrow(self) X", experimentalFeatures: [.nonescapableTypes])
+    assertParse("func foo() -> dependsOn(self) X", experimentalFeatures: [.nonescapableTypes])
 
     assertParse(
-      "func foo() -> _borrow1️⃣(0)2️⃣ X",
+      "func foo() -> dependsOn1️⃣(0)2️⃣ X",
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -415,14 +411,14 @@ final class TypeTests: ParserTestCase {
         ),
       ],
       fixedSource: """
-        func foo() -> _borrow
+        func foo() -> dependsOn
         (0)
         X
         """
     )
 
     assertParse(
-      "func foo() -> _borrow(1️⃣-1) X",
+      "func foo() -> dependsOn(1️⃣-1) X",
       diagnostics: [
         DiagnosticSpec(
           message: "expected parameter reference in lifetime specifier",
@@ -430,7 +426,7 @@ final class TypeTests: ParserTestCase {
         ),
         DiagnosticSpec(message: "unexpected code '-1' in lifetime specifier"),
       ],
-      fixedSource: "func foo() -> _borrow(<#identifier#>-1) X",
+      fixedSource: "func foo() -> dependsOn(<#identifier#>-1) X",
       experimentalFeatures: [.nonescapableTypes]
     )
   }