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..2658b4e0b3f 100644
--- a/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift
@@ -553,25 +553,14 @@ public let TYPE_NODES: [Node] = [
       ### Example
       `borrow(data)` in `func foo(data: Array<Item>) -> borrow(data) ComplexReferenceType`
       """,
-    traits: [
-      "Parenthesized"
-    ],
     children: [
-      Child(
-        name: "leftParen",
-        kind: .token(choices: [.token(.leftParen)])
-      ),
       Child(
         name: "arguments",
         kind: .collection(kind: .lifetimeSpecifierArgumentList, collectionElementName: "Arguments"),
         documentation: """
           The function parameters that the lifetime of the annotated type depends on.
           """
-      ),
-      Child(
-        name: "rightParen",
-        kind: .token(choices: [.token(.rightParen)])
-      ),
+      )
     ]
   ),
 
@@ -581,21 +570,32 @@ public let TYPE_NODES: [Node] = [
     experimentalFeature: .nonescapableTypes,
     nameForDiagnostics: "lifetime specifier",
     documentation: "A specifier that specifies function parameter on whose lifetime a type depends",
+    traits: [
+      "Parenthesized"
+    ],
     children: [
       Child(
-        name: "specifier",
-        kind: .token(choices: [
-          .keyword(._copy),
-          .keyword(._consume),
-          .keyword(._borrow),
-          .keyword(._mutate),
-        ]),
+        name: "dependsOnKeyword",
+        kind: .token(choices: [.keyword(.dependsOn)]),
         documentation: "The specifier token that's attached to the type."
       ),
+      Child(
+        name: "leftParen",
+        kind: .token(choices: [.token(.leftParen)])
+      ),
+      Child(
+        name: "scopedKeyword",
+        kind: .token(choices: [.keyword(.scoped)]),
+        isOptional: true
+      ),
       Child(
         name: "arguments",
         kind: .node(kind: .lifetimeSpecifierArguments)
       ),
+      Child(
+        name: "rightParen",
+        kind: .token(choices: [.token(.rightParen)])
+      ),
     ]
   ),
 
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..99958f0deae 100644
--- a/Sources/SwiftParser/Types.swift
+++ b/Sources/SwiftParser/Types.swift
@@ -900,33 +900,33 @@ 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 specifier = self.eat(TokenSpec(.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),
         arena: self.arena
       )
       let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-        specifier: specifier,
+        dependsOnKeyword: specifier,
+        leftParen: missingToken(.leftParen),
+        scopedKeyword: nil,
         arguments: arguments,
+        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()
@@ -948,15 +948,16 @@ extension Parser {
     let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(elements: arguments, arena: self.arena)
     let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
     let argumentsSyntax = RawLifetimeSpecifierArgumentsSyntax(
-      leftParen: leftParen,
       arguments: lifetimeSpecifierArgumentList,
-      unexpectedBeforeRightParen,
-      rightParen: rightParen,
       arena: self.arena
     )
     let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-      specifier: specifier,
+      dependsOnKeyword: specifier,
+      leftParen: leftParen,
+      scopedKeyword: scoped,
       arguments: argumentsSyntax,
+      unexpectedBeforeRightParen,
+      rightParen: rightParen,
       arena: self.arena
     )
     return .lifetimeTypeSpecifier(lifetimeSpecifier)
@@ -976,20 +977,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(TokenSpec(.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..b2666dca2a3 100644
--- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
+++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -2009,30 +2009,34 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \LifetimeSpecifierArgumentSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeLeftParen:
-    return "unexpectedBeforeLeftParen"
-  case \LifetimeSpecifierArgumentsSyntax.leftParen:
-    return "leftParen"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenLeftParenAndArguments:
-    return "unexpectedBetweenLeftParenAndArguments"
+  case \LifetimeSpecifierArgumentsSyntax.unexpectedBeforeArguments:
+    return "unexpectedBeforeArguments"
   case \LifetimeSpecifierArgumentsSyntax.arguments:
     return "arguments"
-  case \LifetimeSpecifierArgumentsSyntax.unexpectedBetweenArgumentsAndRightParen:
+  case \LifetimeSpecifierArgumentsSyntax.unexpectedAfterArguments:
+    return "unexpectedAfterArguments"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBeforeDependsOnKeyword:
+    return "unexpectedBeforeDependsOnKeyword"
+  case \LifetimeTypeSpecifierSyntax.dependsOnKeyword:
+    return "dependsOnKeyword"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenDependsOnKeywordAndLeftParen:
+    return "unexpectedBetweenDependsOnKeywordAndLeftParen"
+  case \LifetimeTypeSpecifierSyntax.leftParen:
+    return "leftParen"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenLeftParenAndScopedKeyword:
+    return "unexpectedBetweenLeftParenAndScopedKeyword"
+  case \LifetimeTypeSpecifierSyntax.scopedKeyword:
+    return "scopedKeyword"
+  case \LifetimeTypeSpecifierSyntax.unexpectedBetweenScopedKeywordAndArguments:
+    return "unexpectedBetweenScopedKeywordAndArguments"
+  case \LifetimeTypeSpecifierSyntax.arguments:
+    return "arguments"
+  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/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
index 83c8529f9a2..e842583feb6 100644
--- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
@@ -779,7 +779,7 @@ extension LabeledSpecializeArgumentSyntax: WithTrailingCommaSyntax {}
 
 extension LifetimeSpecifierArgumentSyntax: WithTrailingCommaSyntax {}
 
-extension LifetimeSpecifierArgumentsSyntax: ParenthesizedSyntax {}
+extension LifetimeTypeSpecifierSyntax: ParenthesizedSyntax {}
 
 extension MacroDeclSyntax: NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
index d5e9ab34c9d..56087afd1f9 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
@@ -1082,55 +1082,31 @@ public struct RawLifetimeSpecifierArgumentsSyntax: RawSyntaxNodeProtocol {
   }
   
   public init(
-      _ unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? = nil, 
-      leftParen: RawTokenSyntax, 
-      _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBeforeArguments: RawUnexpectedNodesSyntax? = nil, 
       arguments: RawLifetimeSpecifierArgumentListSyntax, 
-      _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, 
-      rightParen: RawTokenSyntax, 
-      _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .lifetimeSpecifierArguments, uninitializedCount: 7, arena: arena) { layout in
+      kind: .lifetimeSpecifierArguments, uninitializedCount: 3, 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] = unexpectedBeforeArguments?.raw
+      layout[1] = arguments.raw
+      layout[2] = unexpectedAfterArguments?.raw
     }
     self.init(unchecked: raw)
   }
   
-  public var unexpectedBeforeLeftParen: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforeArguments: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var leftParen: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  
-  public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  
   public var arguments: RawLifetimeSpecifierArgumentListSyntax {
-    layoutView.children[3].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))!
-  }
-  
-  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  
-  public var rightParen: RawTokenSyntax {
-    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+    layoutView.children[1].map(RawLifetimeSpecifierArgumentListSyntax.init(raw:))!
   }
   
-  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1167,44 +1143,80 @@ public struct RawLifetimeTypeSpecifierSyntax: RawSyntaxNodeProtocol {
   }
   
   public init(
-      _ unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? = nil, 
-      specifier: RawTokenSyntax, 
-      _ unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? = nil, 
+      dependsOnKeyword: RawTokenSyntax, 
+      _ unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? = nil, 
+      leftParen: RawTokenSyntax, 
+      _ unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? = nil, 
+      scopedKeyword: RawTokenSyntax?, 
+      _ unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? = nil, 
       arguments: RawLifetimeSpecifierArgumentsSyntax, 
-      _ unexpectedAfterArguments: RawUnexpectedNodesSyntax? = nil, 
+      _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil, 
+      rightParen: RawTokenSyntax, 
+      _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil, 
       arena: __shared SyntaxArena
     ) {
     let raw = RawSyntax.makeLayout(
-      kind: .lifetimeTypeSpecifier, uninitializedCount: 5, arena: arena) { layout in
+      kind: .lifetimeTypeSpecifier, uninitializedCount: 11, 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
+      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 unexpectedBeforeSpecifier: RawUnexpectedNodesSyntax? {
+  public var unexpectedBeforeDependsOnKeyword: RawUnexpectedNodesSyntax? {
     layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var specifier: RawTokenSyntax {
+  public var dependsOnKeyword: RawTokenSyntax {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
   
-  public var unexpectedBetweenSpecifierAndArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenDependsOnKeywordAndLeftParen: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
   
-  public var arguments: RawLifetimeSpecifierArgumentsSyntax {
-    layoutView.children[3].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))!
+  public var leftParen: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
   }
   
-  public var unexpectedAfterArguments: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenLeftParenAndScopedKeyword: RawUnexpectedNodesSyntax? {
     layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+  
+  public var scopedKeyword: RawTokenSyntax? {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
+  }
+  
+  public var unexpectedBetweenScopedKeywordAndArguments: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var arguments: RawLifetimeSpecifierArgumentsSyntax {
+    layoutView.children[7].map(RawLifetimeSpecifierArgumentsSyntax.init(raw:))!
+  }
+  
+  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  
+  public var rightParen: RawTokenSyntax {
+    layoutView.children[9].map(RawTokenSyntax.init(raw:))!
+  }
+  
+  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
index 8d22721337f..7a685aa4bb8 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -1726,26 +1726,23 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     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)
+    assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.leftParen)]))
+    assertNoError(kind, 1, verify(layout[1], as: RawLifetimeSpecifierArgumentListSyntax.self))
     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: RawLifetimeSpecifierArgumentsSyntax.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..9f02ec31ce5 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
@@ -1801,9 +1801,7 @@ public struct LifetimeSpecifierArgumentSyntax: SyntaxProtocol, SyntaxHashable, _
 ///
 /// ### Children
 /// 
-///  - `leftParen`: `(`
 ///  - `arguments`: `LifetimeSpecifierArgumentListSyntax`
-///  - `rightParen`: `)`
 #if compiler(>=5.8)
 @_spi(ExperimentalLanguageFeatures)
 #endif
@@ -1823,36 +1821,16 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   ///   - 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,
-      leftParen: TokenSyntax = .leftParenToken(),
-      _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBeforeArguments: UnexpectedNodesSyntax? = nil,
       arguments: LifetimeSpecifierArgumentListSyntax,
-      _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil,
-      rightParen: TokenSyntax = .rightParenToken(),
-      _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil,
+      _ 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(), (
-            unexpectedBeforeLeftParen, 
-            leftParen, 
-            unexpectedBetweenLeftParenAndArguments, 
-            arguments, 
-            unexpectedBetweenArgumentsAndRightParen, 
-            rightParen, 
-            unexpectedAfterRightParen
-          ))) { (arena, _) in
-      let layout: [RawSyntax?] = [
-          unexpectedBeforeLeftParen?.raw, 
-          leftParen.raw, 
-          unexpectedBetweenLeftParenAndArguments?.raw, 
-          arguments.raw, 
-          unexpectedBetweenArgumentsAndRightParen?.raw, 
-          rightParen.raw, 
-          unexpectedAfterRightParen?.raw
-        ]
+    self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeArguments, arguments, unexpectedAfterArguments))) { (arena, _) in
+      let layout: [RawSyntax?] = [unexpectedBeforeArguments?.raw, arguments.raw, unexpectedAfterArguments?.raw]
       let raw = RawSyntax.makeLayout(
         kind: SyntaxKind.lifetimeSpecifierArguments,
         from: layout,
@@ -1865,7 +1843,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     }
   }
   
-  public var unexpectedBeforeLeftParen: UnexpectedNodesSyntax? {
+  public var unexpectedBeforeArguments: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -1874,34 +1852,13 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     }
   }
   
-  /// ### Tokens
-  /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be `(`.
-  public var leftParen: 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)
-    }
-  }
-  
-  public var unexpectedBetweenLeftParenAndArguments: 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)
-    }
-  }
-  
   /// 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: 1)!.cast(LifetimeSpecifierArgumentListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
     }
   }
   
@@ -1916,7 +1873,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
   public func addArguments(_ element: LifetimeSpecifierArgumentSyntax) -> LifetimeSpecifierArgumentsSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
-    if let col = raw.layoutView!.children[3] {
+    if let col = raw.layoutView!.children[1] {
       collection = col.layoutView!.appending(element.raw, arena: arena)
     } else {
       collection = RawSyntax.makeLayout(kind: SyntaxKind.lifetimeSpecifierArgumentList,
@@ -1924,7 +1881,7 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
     }
     return Syntax(self)
       .replacingChild(
-        at: 3, 
+        at: 1, 
         with: collection, 
         rawNodeArena: arena, 
         allocationArena: arena
@@ -1932,46 +1889,17 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
       .cast(LifetimeSpecifierArgumentsSyntax.self)
   }
   
-  public var unexpectedBetweenArgumentsAndRightParen: 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(LifetimeSpecifierArgumentsSyntax.self)
-    }
-  }
-  
-  /// ### Tokens
-  /// 
-  /// 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)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
-    }
-  }
-  
-  public var unexpectedAfterRightParen: UnexpectedNodesSyntax? {
+  public var unexpectedAfterArguments: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeSpecifierArgumentsSyntax.self)
     }
   }
   
   public static var structure: SyntaxNodeStructure {
-    return .layout([
-          \Self.unexpectedBeforeLeftParen, 
-          \Self.leftParen, 
-          \Self.unexpectedBetweenLeftParenAndArguments, 
-          \Self.arguments, 
-          \Self.unexpectedBetweenArgumentsAndRightParen, 
-          \Self.rightParen, 
-          \Self.unexpectedAfterRightParen
-        ])
+    return .layout([\Self.unexpectedBeforeArguments, \Self.arguments, \Self.unexpectedAfterArguments])
   }
 }
 
@@ -1983,8 +1911,11 @@ public struct LifetimeSpecifierArgumentsSyntax: SyntaxProtocol, SyntaxHashable,
 ///
 /// ### Children
 /// 
-///  - `specifier`: (`_copy` | `_consume` | `_borrow` | `_mutate`)
+///  - `dependsOnKeyword`: `dependsOn`
+///  - `leftParen`: `(`
+///  - `scopedKeyword`: `scoped`?
 ///  - `arguments`: `LifetimeSpecifierArgumentsSyntax`
+///  - `rightParen`: `)`
 ///
 /// ### Contained in
 /// 
@@ -2004,33 +1935,51 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
   
   /// - 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.
+  ///   - dependsOnKeyword: 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,
+      _ unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? = nil,
+      dependsOnKeyword: TokenSyntax = .keyword(.dependsOn),
+      _ unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? = nil,
+      leftParen: TokenSyntax = .leftParenToken(),
+      _ unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? = nil,
+      scopedKeyword: TokenSyntax? = nil,
+      _ unexpectedBetweenScopedKeywordAndArguments: UnexpectedNodesSyntax? = nil,
       arguments: LifetimeSpecifierArgumentsSyntax,
-      _ unexpectedAfterArguments: UnexpectedNodesSyntax? = nil,
+      _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil,
+      rightParen: TokenSyntax = .rightParenToken(),
+      _ unexpectedAfterRightParen: 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, 
+            unexpectedBeforeDependsOnKeyword, 
+            dependsOnKeyword, 
+            unexpectedBetweenDependsOnKeywordAndLeftParen, 
+            leftParen, 
+            unexpectedBetweenLeftParenAndScopedKeyword, 
+            scopedKeyword, 
+            unexpectedBetweenScopedKeywordAndArguments, 
             arguments, 
-            unexpectedAfterArguments
+            unexpectedBetweenArgumentsAndRightParen, 
+            rightParen, 
+            unexpectedAfterRightParen
           ))) { (arena, _) in
       let layout: [RawSyntax?] = [
-          unexpectedBeforeSpecifier?.raw, 
-          specifier.raw, 
-          unexpectedBetweenSpecifierAndArguments?.raw, 
+          unexpectedBeforeDependsOnKeyword?.raw, 
+          dependsOnKeyword.raw, 
+          unexpectedBetweenDependsOnKeywordAndLeftParen?.raw, 
+          leftParen.raw, 
+          unexpectedBetweenLeftParenAndScopedKeyword?.raw, 
+          scopedKeyword?.raw, 
+          unexpectedBetweenScopedKeywordAndArguments?.raw, 
           arguments.raw, 
-          unexpectedAfterArguments?.raw
+          unexpectedBetweenArgumentsAndRightParen?.raw, 
+          rightParen.raw, 
+          unexpectedAfterRightParen?.raw
         ]
       let raw = RawSyntax.makeLayout(
         kind: SyntaxKind.lifetimeTypeSpecifier,
@@ -2044,7 +1993,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
     }
   }
   
-  public var unexpectedBeforeSpecifier: UnexpectedNodesSyntax? {
+  public var unexpectedBeforeDependsOnKeyword: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -2057,12 +2006,8 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
   ///
   /// ### 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 {
+  /// 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)
     }
@@ -2071,7 +2016,7 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
     }
   }
   
-  public var unexpectedBetweenSpecifierAndArguments: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenDependsOnKeywordAndLeftParen: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -2080,16 +2025,19 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
     }
   }
   
-  public var arguments: LifetimeSpecifierArgumentsSyntax {
+  /// ### 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(LifetimeSpecifierArgumentsSyntax.self)
+      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 unexpectedAfterArguments: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenLeftParenAndScopedKeyword: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
@@ -2098,13 +2046,79 @@ public struct LifetimeTypeSpecifierSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
     }
   }
   
+  /// ### 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)
+    }
+  }
+  
+  public var arguments: LifetimeSpecifierArgumentsSyntax {
+    get {
+      return Syntax(self).child(at: 7)!.cast(LifetimeSpecifierArgumentsSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  public var unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be `)`.
+  public var rightParen: TokenSyntax {
+    get {
+      return Syntax(self).child(at: 9)!.cast(TokenSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
+  public var unexpectedAfterRightParen: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(LifetimeTypeSpecifierSyntax.self)
+    }
+  }
+  
   public static var structure: SyntaxNodeStructure {
     return .layout([
-          \Self.unexpectedBeforeSpecifier, 
-          \Self.specifier, 
-          \Self.unexpectedBetweenSpecifierAndArguments, 
+          \Self.unexpectedBeforeDependsOnKeyword, 
+          \Self.dependsOnKeyword, 
+          \Self.unexpectedBetweenDependsOnKeywordAndLeftParen, 
+          \Self.leftParen, 
+          \Self.unexpectedBetweenLeftParenAndScopedKeyword, 
+          \Self.scopedKeyword, 
+          \Self.unexpectedBetweenScopedKeywordAndArguments, 
           \Self.arguments, 
-          \Self.unexpectedAfterArguments
+          \Self.unexpectedBetweenArgumentsAndRightParen, 
+          \Self.rightParen, 
+          \Self.unexpectedAfterRightParen
         ])
   }
 }
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]
     )
   }