Remove withKind from TokenSyntax

`with(\.tokenKind, newValue)` should be used instead.

Author: ahoppen

Examples/Sources/AddOneToIntegerLiterals/AddOneToIntegerLiterals.swift

@@ -31,7 +31,7 @@ private class AddOneToIntegerLiterals: SyntaxRewriter {
     let int = Int(integerText)!
 
     // Create a new integer literal token with `int + 1` as its text.
-    let newIntegerLiteralToken = token.withKind(.integerLiteral("\(int + 1)"))
+    let newIntegerLiteralToken = token.with(\.tokenKind, .integerLiteral("\(int + 1)"))
 
     // Return the new integer literal.
     return newIntegerLiteralToken

Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift

@@ -204,7 +204,7 @@ public extension SwiftSyntax.TokenDiagnostic {
         .replacingFirstOccurence(of: "“", with: #"""#)
         .replacingLastOccurence(of: "”", with: #"""#)
 
-      let fixedToken = token.withKind(TokenKind.fromRaw(kind: rawKind, text: replacedText))
+      let fixedToken = token.with(\.tokenKind, TokenKind.fromRaw(kind: rawKind, text: replacedText))
       return [
         FixIt(message: .replaceCurlyQuoteByNormalQuote, changes: [.replace(oldNode: Syntax(token), newNode: Syntax(fixedToken))])
       ]

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -20,9 +20,9 @@ fileprivate extension TokenSyntax {
   var negatedAvailabilityKeyword: TokenSyntax {
     switch self.tokenKind {
     case .poundAvailableKeyword:
-      return self.withKind(.poundUnavailableKeyword)
+      return self.with(\.tokenKind, .poundUnavailableKeyword)
     case .poundUnavailableKeyword:
-      return self.withKind(.poundAvailableKeyword)
+      return self.with(\.tokenKind, .poundAvailableKeyword)
     default:
       preconditionFailure("The availability token of an AvailabilityConditionSyntax should always be #available or #unavailable")
     }

Sources/SwiftRefactor/AddSeparatorsToIntegerLiteral.swift

@@ -51,7 +51,7 @@ public struct AddSeparatorsToIntegerLiteral: RefactoringProvider {
     formattedText += value.byAddingGroupSeparators(at: lit.idealGroupSize)
     return
       lit
-      .with(\.digits, lit.digits.withKind(.integerLiteral(formattedText)))
+      .with(\.digits, lit.digits.with(\.tokenKind, .integerLiteral(formattedText)))
   }
 }
 

Sources/SwiftRefactor/FormatRawStringLiteral.swift

@@ -49,15 +49,15 @@ public struct FormatRawStringLiteral: RefactoringProvider {
     guard maximumHashes > 0 else {
       return
         lit
-        .with(\.openDelimiter, lit.openDelimiter?.withKind(.rawStringDelimiter("")))
-        .with(\.closeDelimiter, lit.closeDelimiter?.withKind(.rawStringDelimiter("")))
+        .with(\.openDelimiter, lit.openDelimiter?.with(\.tokenKind, .rawStringDelimiter("")))
+        .with(\.closeDelimiter, lit.closeDelimiter?.with(\.tokenKind, .rawStringDelimiter("")))
     }
 
     let delimiters = String(repeating: "#", count: maximumHashes + 1)
     return
       lit
-      .with(\.openDelimiter, lit.openDelimiter?.withKind(.rawStringDelimiter(delimiters)))
-      .with(\.closeDelimiter, lit.closeDelimiter?.withKind(.rawStringDelimiter(delimiters)))
+      .with(\.openDelimiter, lit.openDelimiter?.with(\.tokenKind, .rawStringDelimiter(delimiters)))
+      .with(\.closeDelimiter, lit.closeDelimiter?.with(\.tokenKind, .rawStringDelimiter(delimiters)))
   }
 }
 

Sources/SwiftRefactor/RemoveSeparatorsFromIntegerLiteral.swift

@@ -32,6 +32,6 @@ public struct RemoveSeparatorsFromIntegerLiteral: RefactoringProvider {
       return lit
     }
     let formattedText = lit.digits.text.filter({ $0 != "_" })
-    return lit.with(\.digits, lit.digits.withKind(.integerLiteral(formattedText)))
+    return lit.with(\.digits, lit.digits.with(\.tokenKind, .integerLiteral(formattedText)))
   }
 }

Sources/SwiftSyntax/TokenSyntax.swift

@@ -68,18 +68,6 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     return tokenKind.text
   }
 
-  /// Returns a new TokenSyntax with its kind replaced
-  /// by the provided token kind.
-  public func withKind(_ tokenKind: TokenKind) -> TokenSyntax {
-    guard raw.kind == .token else {
-      fatalError("TokenSyntax must have token as its raw")
-    }
-    let arena = SyntaxArena()
-    let newRaw = tokenView.withKind(tokenKind, arena: arena)
-    let newData = data.replacingSelf(newRaw, arena: arena)
-    return TokenSyntax(newData)
-  }
-
   /// The leading trivia (spaces, newlines, etc.) associated with this token.
   public var leadingTrivia: Trivia {
     get {
@@ -106,7 +94,13 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
       return tokenView.formKind()
     }
     set {
-      self = withKind(newValue)
+      guard raw.kind == .token else {
+        fatalError("TokenSyntax must have token as its raw")
+      }
+      let arena = SyntaxArena()
+      let newRaw = tokenView.withKind(newValue, arena: arena)
+      let newData = data.replacingSelf(newRaw, arena: arena)
+      self = TokenSyntax(newData)
     }
   }
 

Tests/SwiftSyntaxTest/RawSyntaxTests.swift

@@ -142,7 +142,7 @@ final class RawSyntaxTests: XCTestCase {
       XCTAssertEqual(ident.description, "\nfoo ")
 
       let identSyntax = Syntax(raw: ident.raw).as(TokenSyntax.self)!
-      let barIdentSyntax = identSyntax.withKind(.keyword(.open))
+      let barIdentSyntax = identSyntax.with(\.tokenKind, .keyword(.open))
       let barIdent = barIdentSyntax.raw.as(RawTokenSyntax.self)!
 
       XCTAssertEqual(barIdent.tokenKind, .keyword)