Merge pull request #2574 from apple/cpdependson

[6.0] Update lifetime dependence syntax

Author: meg-gupta

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:

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,

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"),
       ]
     )
   }

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,

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 {

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 {

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: