Stop parsing #keyPath and #selector as special grammar productions

Sources/SwiftParser/Expressions.swift

@@ -973,8 +973,6 @@ extension Parser {
   ///     primary-expression → implicit-member-expression
   ///     primary-expression → wildcard-expression
   ///     primary-expression → key-path-expression
-  ///     primary-expression → selector-expression
-  ///     primary-expression → key-path-string-expression
   ///     primary-expression → macro-expansion-expression
   @_spi(RawSyntax)
   public mutating func parsePrimaryExpression(
@@ -1081,11 +1079,6 @@ extension Parser {
         self.parseMacroExpansionExpr(pattern: pattern, flavor: flavor)
       )
 
-    case (.poundSelectorKeyword, _)?:
-      return RawExprSyntax(self.parseObjectiveCSelectorLiteral())
-    case (.poundKeyPathKeyword, _)?:
-      return RawExprSyntax(self.parseObjectiveCKeyPathExpression())
-
     case (.leftBrace, _)?:     // expr-closure
       return RawExprSyntax(self.parseClosureExpression())
     case (.period, let handle)?,              //=.foo
@@ -1653,53 +1646,6 @@ extension Parser {
   }
 }
 
-extension Parser {
-  /// Parse an Objective-C #keypath literal.
-  ///
-  /// Grammar
-  /// =======
-  ///
-  ///     key-path-string-expression → '#keyPath' '(' expression ')'
-  @_spi(RawSyntax)
-  public mutating func parseObjectiveCKeyPathExpression() -> RawObjcKeyPathExprSyntax {
-    let (unexpectedBeforeKeyword, keyword) = self.expect(.poundKeyPathKeyword)
-    // Parse the leading '('.
-    let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen)
-
-    // Parse the sequence of unqualified-names.
-    var elements = [RawObjcNamePieceSyntax]()
-    do {
-      var flags: DeclNameOptions = []
-      var keepGoing: RawTokenSyntax? = nil
-      var loopProgress = LoopProgressCondition()
-      repeat {
-        // Parse the next name.
-        let (name, args) = self.parseDeclNameRef(flags)
-        assert(args == nil, "Found arguments but did not pass argument flag?")
-
-        // After the first component, we can start parsing keywords.
-        flags.formUnion(.keywords)
-
-        // Parse the next period to continue the path.
-        keepGoing = self.consume(if: .period)
-        elements.append(RawObjcNamePieceSyntax(
-          name: name, dot: keepGoing, arena: self.arena))
-      } while keepGoing != nil && loopProgress.evaluate(currentToken)
-    }
-
-    // Parse the closing ')'.
-    let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
-    return RawObjcKeyPathExprSyntax(
-      unexpectedBeforeKeyword,
-      keyPath: keyword,
-      unexpectedBeforeLParen,
-      leftParen: lparen,
-      name: RawObjcNameSyntax(elements: elements, arena: self.arena),
-      unexpectedBeforeRParen,
-      rightParen: rparen, arena: self.arena)
-  }
-}
-
 extension Parser {
   /// Parse a 'super' reference to the superclass instance of a class.
   ///
@@ -1925,48 +1871,6 @@ extension Parser {
   }
 }
 
-extension Parser {
-  /// Parse a #selector expression.
-  ///
-  /// Grammar
-  /// =======
-  ///
-  ///     selector-expression → '#selector' '(' expression )
-  ///     selector-expression → '#selector' '(' 'getter' ':' expression ')'
-  ///     selector-expression → '#selector' '(' 'setter' ':' expression ')'
-  @_spi(RawSyntax)
-  public mutating func parseObjectiveCSelectorLiteral() -> RawObjcSelectorExprSyntax {
-    // Consume '#selector'.
-    let (unexpectedBeforeSelector, selector) = self.expect(.poundSelectorKeyword)
-    // Parse the leading '('.
-    let (unexpectedBeforeLParen, lparen) = self.expect(.leftParen)
-
-    // Parse possible 'getter:' or 'setter:' modifiers, and determine
-    // the kind of selector we're working with.
-    let kindAndColon = self.consume(
-      if: { $0.isContextualKeyword(["getter", "setter"])},
-      followedBy: { $0.tokenKind == .colon }
-    )
-    let (kind, colon) = (kindAndColon?.0, kindAndColon?.1)
-
-    // Parse the subexpression.
-    let subexpr = self.parseExpression()
-    // Parse the closing ')'.
-    let (unexpectedBeforeRParen, rparen) = self.expect(.rightParen)
-    return RawObjcSelectorExprSyntax(
-      unexpectedBeforeSelector,
-      poundSelector: selector,
-      unexpectedBeforeLParen,
-      leftParen: lparen,
-      kind: kind,
-      colon: colon,
-      name: subexpr,
-      unexpectedBeforeRParen,
-      rightParen: rparen,
-      arena: self.arena)
-  }
-}
-
 extension Parser {
   /// Parse a closure expression.
   ///

Sources/SwiftParser/Lexer.swift

@@ -1565,8 +1565,6 @@ extension Lexer.Cursor {
 
     let kind: RawTokenKind
     switch literal {
-    case "keyPath": kind = .poundKeyPathKeyword
-    case "selector": kind = .poundSelectorKeyword
     case "assert": kind = .poundAssertKeyword
     case "sourceLocation": kind = .poundSourceLocationKeyword
     case "warning": kind = .poundWarningKeyword

Sources/SwiftParser/RawTokenKindSubset.swift

@@ -700,8 +700,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
   case nilKeyword
   case period
   case pound
-  case poundKeyPathKeyword
-  case poundSelectorKeyword
   case prefixPeriod
   case regexLiteral
   case selfKeyword
@@ -731,8 +729,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .nilKeyword: self = .nilKeyword
     case .period: self = .period
     case .pound: self = .pound
-    case .poundKeyPathKeyword: self = .poundKeyPathKeyword
-    case .poundSelectorKeyword: self = .poundSelectorKeyword
     case .prefixPeriod: self = .prefixPeriod
     case .regexLiteral: self = .regexLiteral
     case .selfKeyword: self = .selfKeyword
@@ -765,8 +761,6 @@ enum PrimaryExpressionStart: RawTokenKindSubset {
     case .nilKeyword: return .nilKeyword
     case .period: return .period
     case .pound: return .pound
-    case .poundKeyPathKeyword: return .poundKeyPathKeyword
-    case .poundSelectorKeyword: return .poundSelectorKeyword
     case .prefixPeriod: return .prefixPeriod
     case .regexLiteral: return .regexLiteral
     case .selfKeyword: return .selfKeyword

Tests/SwiftParserTest/ExpressionTests.swift

@@ -637,11 +637,10 @@ final class ExpressionTests: XCTestCase {
       ]
     )
 
-    AssertParse("#keyPath(1️⃣(b:2️⃣)",
+    AssertParse("#keyPath((b:1️⃣)2️⃣",
                 diagnostics: [
-                  DiagnosticSpec(locationMarker: "1️⃣", message: "expected identifier in '#keyPath' expression"),
-                  DiagnosticSpec(locationMarker: "1️⃣", message: "expected ')' to end '#keyPath' expression"),
-                  DiagnosticSpec(locationMarker: "2️⃣", message: "expected value in function call"),
+                  DiagnosticSpec(locationMarker: "1️⃣", message: "expected value in tuple"),
+                  DiagnosticSpec(locationMarker: "2️⃣", message: "expected ')' to end pound literal expression"),
                 ])
   }