Delete dependsOn syntax

Author: meg-gupta

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -167,7 +167,6 @@ public enum Keyword: CaseIterable {
   case `default`
   case `defer`
   case `deinit`
-  case dependsOn
   case deprecated
   case derivative
   case didSet
@@ -257,7 +256,6 @@ public enum Keyword: CaseIterable {
   case reverse
   case right
   case safe
-  case scoped
   case `self`
   case sending
   case `Self`
@@ -476,8 +474,6 @@ 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:
@@ -654,8 +650,6 @@ 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/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/TokenPrecedence.swift

@@ -236,7 +236,7 @@ enum TokenPrecedence: Comparable {
       .convenience, .override, .package, .open,
       .__setter_access, .indirect, .isolated, .nonisolated, .distributed, ._local,
       .inout, ._mutating, ._borrow, ._borrowing, .borrowing, ._consuming, .consuming, .consume,
-      .dependsOn, .scoped, .sending,
+      .sending,
       // Accessors
       .get, .set, .didSet, .willSet, .unsafeAddress, .addressWithOwner, .addressWithNativeOwner, .unsafeMutableAddress,
       .mutableAddressWithOwner, .mutableAddressWithNativeOwner, ._read, .read, ._modify, .modify,

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:

Tests/SwiftParserTest/DeclarationTests.swift

@@ -3271,11 +3271,6 @@ final class DeclarationTests: ParserTestCase {
   }
 
   func testInitializerWithReturnType() {
-    assertParse(
-      "init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array<Int>) -> dependsOn(a) Self",
-      experimentalFeatures: .nonescapableTypes
-    )
-
     // Not actually valid, needs to be diagnosed during type checking
     assertParse(
       "public init() 1️⃣->  Int",

Tests/SwiftParserTest/TypeTests.swift

@@ -433,104 +433,4 @@ final class TypeTests: ParserTestCase {
     assertParse("func foo2(_ a: borrowing _const String) {}")
   }
 
-  func testLifetimeSpecifier() {
-    assertParse("func foo() -> dependsOn(x) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse("func foo() -> dependsOn(x, y) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse(
-      "func foo() -> dependsOn(1️⃣) X",
-      diagnostics: [
-        DiagnosticSpec(
-          locationMarker: "1️⃣",
-          message: "expected parameter reference in lifetime specifier",
-          fixIts: ["insert parameter reference"]
-        )
-      ],
-      fixedSource: "func foo() -> dependsOn(<#identifier#>) X",
-      experimentalFeatures: [.nonescapableTypes]
-    )
-
-    assertParse(
-      "func foo() -> dependsOn(x,1️⃣) X",
-      diagnostics: [
-        DiagnosticSpec(
-          locationMarker: "1️⃣",
-          message: "expected parameter reference in lifetime specifier",
-          fixIts: ["insert parameter reference"]
-        )
-      ],
-      fixedSource: "func foo() -> dependsOn(x, <#identifier#>) X",
-      experimentalFeatures: [.nonescapableTypes]
-    )
-
-    assertParse("func foo() -> dependsOn(x) dependsOn(scoped y) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse("func foo() -> dependsOn(scoped x) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse(
-      "func foo() -> dependsOn1️⃣ X",
-      diagnostics: [
-        DiagnosticSpec(
-          locationMarker: "1️⃣",
-          message: "expected '(', parameter reference, and ')' in lifetime specifier",
-          fixIts: ["insert '(', parameter reference, and ')'"]
-        )
-      ],
-      fixedSource: "func foo() -> dependsOn(<#identifier#>) X",
-      experimentalFeatures: [.nonescapableTypes]
-    )
-
-    assertParse(
-      "func foo() -> dependsOn(1️⃣*) X",
-      diagnostics: [
-        DiagnosticSpec(
-          locationMarker: "1️⃣",
-          message: "expected parameter reference in lifetime specifier",
-          fixIts: ["insert parameter reference"]
-        ),
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '*' in lifetime specifier"),
-      ],
-      fixedSource: "func foo() -> dependsOn(<#identifier#>*) X",
-      experimentalFeatures: [.nonescapableTypes]
-    )
-
-    assertParse("func foo() -> dependsOn(0) X", diagnostics: [], experimentalFeatures: [.nonescapableTypes])
-
-    assertParse("func foo() -> dependsOn(self) X", experimentalFeatures: [.nonescapableTypes])
-
-    assertParse(
-      "func foo() -> dependsOn1️⃣(0)2️⃣ X",
-      diagnostics: [
-        DiagnosticSpec(
-          locationMarker: "1️⃣",
-          message: "consecutive statements on a line must be separated by newline or ';'",
-          fixIts: ["insert newline", "insert ';'"]
-        ),
-        DiagnosticSpec(
-          locationMarker: "2️⃣",
-          message: "consecutive statements on a line must be separated by newline or ';'",
-          fixIts: ["insert newline", "insert ';'"]
-        ),
-      ],
-      fixedSource: """
-        func foo() -> dependsOn
-        (0)
-        X
-        """
-    )
-
-    assertParse(
-      "func foo() -> dependsOn(1️⃣-1) X",
-      diagnostics: [
-        DiagnosticSpec(
-          message: "expected parameter reference in lifetime specifier",
-          fixIts: ["insert parameter reference"]
-        ),
-        DiagnosticSpec(message: "unexpected code '-1' in lifetime specifier"),
-      ],
-      fixedSource: "func foo() -> dependsOn(<#identifier#>-1) X",
-      experimentalFeatures: [.nonescapableTypes]
-    )
-  }
 }