Delete dependsOn syntax

Author: meg-gupta

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -182,9 +182,6 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case labeledSpecializeArgument
   case labeledStmt
   case layoutRequirement
-  case lifetimeSpecifierArgument
-  case lifetimeSpecifierArgumentList
-  case lifetimeTypeSpecifier
   case macroDecl
   case macroExpansionDecl
   case macroExpansionExpr
@@ -290,7 +287,6 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case typeExpr
   case typeInitializerClause
   case typeSpecifier
-  case lifetimeSpecifierArguments
   case typeSpecifierList
   case unavailableFromAsyncAttributeArguments
   case underscorePrivateAttributeArguments

CodeGeneration/Sources/SyntaxSupport/TypeNodes.swift

@@ -500,81 +500,6 @@ public let TYPE_NODES: [Node] = [
     ]
   ),
 
-  Node(
-    kind: .lifetimeSpecifierArgument,
-    base: .syntax,
-    experimentalFeature: .nonescapableTypes,
-    nameForDiagnostics: nil,
-    documentation: """
-      A single argument that can be added to a lifetime specifier like `borrow`, `mutate`, `consume` or `copy`.
-
-      ### Example
-      `data` in `func foo(data: Array<Item>) -> borrow(data) ComplexReferenceType`
-      """,
-    traits: [
-      "WithTrailingComma"
-    ],
-    children: [
-      Child(
-        name: "parameter",
-        kind: .token(choices: [.token(.identifier), .keyword(.self), .token(.integerLiteral)]),
-        nameForDiagnostics: "parameter reference",
-        documentation: """
-          The parameter on which the lifetime of this type depends. 
-
-          This can be an identifier referring to an external parameter name, an integer literal to refer to an unnamed
-          parameter or `self` if the type's lifetime depends on the object the method is called on.
-          """
-      ),
-      Child(
-        name: "trailingComma",
-        kind: .token(choices: [.token(.comma)]),
-        isOptional: true
-      ),
-    ]
-  ),
-
-  Node(
-    kind: .lifetimeSpecifierArgumentList,
-    base: .syntaxCollection,
-    experimentalFeature: .nonescapableTypes,
-    nameForDiagnostics: nil,
-    elementChoices: [.lifetimeSpecifierArgument]
-  ),
-
-  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: "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")
-      ),
-      Child(
-        name: "rightParen",
-        kind: .token(choices: [.token(.rightParen)])
-      ),
-    ]
-  ),
-
   Node(
     kind: .simpleTypeSpecifier,
     base: .syntax,
@@ -602,6 +527,6 @@ public let TYPE_NODES: [Node] = [
     kind: .typeSpecifierList,
     base: .syntaxCollection,
     nameForDiagnostics: nil,
-    elementChoices: [.simpleTypeSpecifier, .lifetimeTypeSpecifier]
+    elementChoices: [.simpleTypeSpecifier]
   ),
 ]

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -550,7 +550,6 @@ 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/Types.swift

@@ -874,64 +874,6 @@ extension Parser.Lookahead {
 }
 
 extension Parser {
-  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 lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(
-        elements: [
-          RawLifetimeSpecifierArgumentSyntax(parameter: missingToken(.identifier), trailingComma: nil, arena: arena)
-        ],
-        arena: self.arena
-      )
-      let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-        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()
-    repeat {
-      let (unexpectedBeforeParameter, parameter) = self.expect(
-        anyIn: LifetimeSpecifierArgumentSyntax.ParameterOptions.self,
-        default: .identifier
-      )
-      keepGoing = self.consume(if: .comma)
-      arguments.append(
-        RawLifetimeSpecifierArgumentSyntax(
-          unexpectedBeforeParameter,
-          parameter: parameter,
-          trailingComma: keepGoing,
-          arena: arena
-        )
-      )
-    } while keepGoing != nil && self.hasProgressed(&loopProgress)
-    let lifetimeSpecifierArgumentList = RawLifetimeSpecifierArgumentListSyntax(elements: arguments, arena: self.arena)
-    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-    let lifetimeSpecifier = RawLifetimeTypeSpecifierSyntax(
-      unexpectedBeforeDependsOnKeyword,
-      dependsOnKeyword: dependsOnKeyword,
-      leftParen: leftParen,
-      scopedKeyword: scoped,
-      arguments: lifetimeSpecifierArgumentList,
-      unexpectedBeforeRightParen,
-      rightParen: rightParen,
-      arena: self.arena
-    )
-    return .lifetimeTypeSpecifier(lifetimeSpecifier)
-  }
-
   private mutating func parseSimpleTypeSpecifier(
     specifierHandle: TokenConsumptionHandle
   ) -> RawTypeSpecifierListSyntax.Element {
@@ -949,12 +891,6 @@ extension Parser {
     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())
-        } else {
-          break SPECIFIER_PARSING
-        }
       } else {
         break SPECIFIER_PARSING
       }

Sources/SwiftParserDiagnostics/SyntaxExtensions.swift

@@ -211,7 +211,6 @@ extension TypeSpecifierListSyntax {
     return self.compactMap { specifier in
       switch specifier {
       case .simpleTypeSpecifier(let specifier): return specifier.specifier
-      case .lifetimeTypeSpecifier: return nil
       #if RESILIENT_LIBRARIES
       @unknown default:
         fatalError()

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -251,8 +251,6 @@ extension SyntaxKind {
       return "labeled statement"
     case .layoutRequirement:
       return "layout requirement"
-    case .lifetimeTypeSpecifier:
-      return "lifetime specifier"
     case .macroDecl:
       return "macro"
     case .macroExpansionDecl: