Replace with(...) calls with in-place mutation.

Also remove some extensions no longer in use, and rewrite the
`DeclModifierListSyntax` helpers to take keywords instead of
strings.

Author: allevato

Sources/SwiftFormat/Core/LegacyTriviaBehavior.swift

@@ -18,15 +18,14 @@ private final class LegacyTriviaBehaviorRewriter: SyntaxRewriter {
   override func visit(_ token: TokenSyntax) -> TokenSyntax {
     var token = token
     if let pendingLeadingTrivia = pendingLeadingTrivia {
-      token = token.with(\.leadingTrivia, pendingLeadingTrivia + token.leadingTrivia)
+      token.leadingTrivia = pendingLeadingTrivia + token.leadingTrivia
       self.pendingLeadingTrivia = nil
     }
     if token.nextToken(viewMode: .sourceAccurate) != nil,
       let firstIndexToMove = token.trailingTrivia.firstIndex(where: shouldTriviaPieceBeMoved)
     {
       pendingLeadingTrivia = Trivia(pieces: Array(token.trailingTrivia[firstIndexToMove...]))
-      token =
-        token.with(\.trailingTrivia, Trivia(pieces: Array(token.trailingTrivia[..<firstIndexToMove])))
+      token.trailingTrivia = Trivia(pieces: Array(token.trailingTrivia[..<firstIndexToMove]))
     }
     return token
   }

Sources/SwiftFormat/Core/ModifierListSyntax+Convenience.swift

@@ -13,15 +13,6 @@
 import SwiftSyntax
 
 extension DeclModifierListSyntax {
-
-  func has(modifier: String) -> Bool {
-    return contains { $0.name.text == modifier }
-  }
-
-  func has(modifier: TokenKind) -> Bool {
-    return contains { $0.name.tokenKind == modifier }
-  }
-
   /// Returns the declaration's access level modifier, if present.
   var accessLevelModifier: DeclModifierSyntax? {
     for modifier in self {
@@ -35,16 +26,35 @@ extension DeclModifierListSyntax {
     return nil
   }
 
-  /// Returns modifier list without the given modifier.
-  func remove(name: String) -> DeclModifierListSyntax {
-    return filter { $0.name.text != name }
+  /// Returns true if the modifier list contains any of the keywords in the given set.
+  func contains(anyOf keywords: Set<Keyword>) -> Bool {
+    return contains {
+      switch $0.name.tokenKind {
+      case .keyword(let keyword): return keywords.contains(keyword)
+      default: return false
+      }
+    }
+  }
+
+  /// Removes any of the modifiers in the given set from the modifier list, mutating it in-place.
+  mutating func remove(anyOf keywords: Set<Keyword>) {
+    self = filter {
+      switch $0.name.tokenKind {
+      case .keyword(let keyword): return !keywords.contains(keyword)
+      default: return true
+      }
+    }
   }
 
-  /// Returns a formatted declaration modifier token with the given name.
-  func createModifierToken(name: String) -> DeclModifierSyntax {
-    let id = TokenSyntax.identifier(name, trailingTrivia: .spaces(1))
-    let newModifier = DeclModifierSyntax(name: id, detail: nil)
-    return newModifier
+
+  /// Returns a copy of the modifier list with any of the modifiers in the given set removed.
+  func removing(anyOf keywords: Set<Keyword>) -> DeclModifierListSyntax {
+    return filter {
+      switch $0.name.tokenKind {
+      case .keyword(let keyword): return !keywords.contains(keyword)
+      default: return true
+      }
+    }
   }
 
   /// Inserts the given modifier into the list at a specific index.

Sources/SwiftFormat/Core/TokenSyntax+Convenience.swift

@@ -13,17 +13,15 @@
 import SwiftSyntax
 
 extension Trivia {
-  var numberOfComments: Int {
-    var count = 0
-    for piece in self {
-      switch piece {
+  var hasAnyComments: Bool {
+    return contains {
+      switch $0 {
       case .lineComment, .docLineComment, .blockComment, .docBlockComment:
-        count += 1
+        return true
       default:
-        continue
+        return false
       }
     }
-    return count
   }
 
   /// Returns whether the trivia contains at least 1 `lineComment`.
@@ -34,16 +32,6 @@ extension Trivia {
     }
   }
 
-  /// Returns this set of trivia, without any whitespace characters.
-  func withoutSpaces() -> Trivia {
-    return Trivia(
-      pieces: filter {
-        if case .spaces = $0 { return false }
-        if case .tabs = $0 { return false }
-        return true
-      })
-  }
-
   /// Returns this set of trivia, without any leading spaces.
   func withoutLeadingSpaces() -> Trivia {
     return Trivia(
@@ -54,15 +42,6 @@ extension Trivia {
       }))
   }
 
-  /// Returns this set of trivia, without any newlines.
-  func withoutNewlines() -> Trivia {
-    return Trivia(
-      pieces: filter {
-        if case .newlines = $0 { return false }
-        return true
-      })
-  }
-
   /// Returns this trivia, excluding the last newline and anything following it.
   ///
   /// If there is no newline in the trivia, it is returned unmodified.
@@ -80,61 +59,6 @@ extension Trivia {
     return Trivia(pieces: self.dropLast(self.count - lastNewlineOffset))
   }
 
-  /// Returns this set of trivia, with all spaces removed except for one at the
-  /// end.
-  func withOneTrailingSpace() -> Trivia {
-    return withoutSpaces() + .spaces(1)
-  }
-
-  /// Returns this set of trivia, with all spaces removed except for one at the
-  /// beginning.
-  func withOneLeadingSpace() -> Trivia {
-    return .spaces(1) + withoutSpaces()
-  }
-
-  /// Returns this set of trivia, with all newlines removed except for one.
-  func withOneLeadingNewline() -> Trivia {
-    return .newlines(1) + withoutNewlines()
-  }
-
-  /// Returns this set of trivia, with all newlines removed except for one.
-  func withOneTrailingNewline() -> Trivia {
-    return withoutNewlines() + .newlines(1)
-  }
-
-  /// Walks through trivia looking for multiple separate trivia entities with
-  /// the same base kind, and condenses them.
-  /// `[.spaces(1), .spaces(2)]` becomes `[.spaces(3)]`.
-  func condensed() -> Trivia {
-    guard var prev = first else { return self }
-    var pieces = [TriviaPiece]()
-    for piece in dropFirst() {
-      switch (prev, piece) {
-      case (.spaces(let l), .spaces(let r)):
-        prev = .spaces(l + r)
-      case (.tabs(let l), .tabs(let r)):
-        prev = .tabs(l + r)
-      case (.newlines(let l), .newlines(let r)):
-        prev = .newlines(l + r)
-      case (.carriageReturns(let l), .carriageReturns(let r)):
-        prev = .carriageReturns(l + r)
-      case (.carriageReturnLineFeeds(let l), .carriageReturnLineFeeds(let r)):
-        prev = .carriageReturnLineFeeds(l + r)
-      case (.verticalTabs(let l), .verticalTabs(let r)):
-        prev = .verticalTabs(l + r)
-      case (.unexpectedText(let l), .unexpectedText(let r)):
-        prev = .unexpectedText(l + r)
-      case (.formfeeds(let l), .formfeeds(let r)):
-        prev = .formfeeds(l + r)
-      default:
-        pieces.append(prev)
-        prev = piece
-      }
-    }
-    pieces.append(prev)
-    return Trivia(pieces: pieces)
-  }
-
   /// Returns `true` if this trivia contains any newlines.
   var containsNewlines: Bool {
     return contains(

Sources/SwiftFormat/Core/Trivia+Convenience.swift

@@ -13,19 +13,20 @@
 import SwiftSyntax
 
 /// Protocol that declares support for accessing and modifying a token that represents a semicolon.
-protocol SemicolonSyntaxProtocol: SyntaxProtocol {
+protocol WithSemicolonSyntax: SyntaxProtocol {
   var semicolon: TokenSyntax? { get set }
 }
 
-extension MemberBlockItemSyntax: SemicolonSyntaxProtocol {}
-extension CodeBlockItemSyntax: SemicolonSyntaxProtocol {}
+extension MemberBlockItemSyntax: WithSemicolonSyntax {}
+extension CodeBlockItemSyntax: WithSemicolonSyntax {}
 
-extension Syntax {
-  func asProtocol(_: SemicolonSyntaxProtocol.Protocol) -> SemicolonSyntaxProtocol? {
-    return self.asProtocol(SyntaxProtocol.self) as? SemicolonSyntaxProtocol
+extension SyntaxProtocol {
+  func asProtocol(_: WithSemicolonSyntax.Protocol) -> WithSemicolonSyntax? {
+    return Syntax(self).asProtocol(SyntaxProtocol.self) as? WithSemicolonSyntax
   }
 
-  func isProtocol(_: SemicolonSyntaxProtocol.Protocol) -> Bool {
-    return self.asProtocol(SemicolonSyntaxProtocol.self) != nil
+  func isProtocol(_: WithSemicolonSyntax.Protocol) -> Bool {
+    return self.asProtocol(WithSemicolonSyntax.self) != nil
   }
 }
+

Sources/SwiftFormat/Core/SemicolonSyntaxProtocol.swift renamed to Sources/SwiftFormat/Core/WithSemicolonSyntax.swift

@@ -914,7 +914,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   }
 
   override func visit(_ node: ArrayExprSyntax) -> SyntaxVisitorContinueKind {
-    if !node.elements.isEmpty || node.rightSquare.leadingTrivia.numberOfComments > 0 {
+    if !node.elements.isEmpty || node.rightSquare.leadingTrivia.hasAnyComments {
       after(node.leftSquare, tokens: .break(.open, size: 0), .open)
       before(node.rightSquare, tokens: .break(.close, size: 0), .close)
     }
@@ -954,8 +954,8 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
     // The node's content is either a `DictionaryElementListSyntax` or a `TokenSyntax` for a colon
     // token (for an empty dictionary).
     if !(node.content.as(DictionaryElementListSyntax.self)?.isEmpty ?? true)
-      || node.content.leadingTrivia.numberOfComments > 0
-      || node.rightSquare.leadingTrivia.numberOfComments > 0
+      || node.content.leadingTrivia.hasAnyComments
+      || node.rightSquare.leadingTrivia.hasAnyComments
     {
       after(node.leftSquare, tokens: .break(.open, size: 0), .open)
       before(node.rightSquare, tokens: .break(.close, size: 0), .close)
@@ -2775,7 +2775,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   ) -> Bool where BodyContents.Element: SyntaxProtocol {
     // If the collection is empty, then any comments that might be present in the block must be
     // leading trivia of the right brace.
-    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.numberOfComments > 0
+    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.hasAnyComments
     // We can't use `count` here because it also includes missing children. Instead, we get an
     // iterator and check if it returns `nil` immediately.
     var contentsIterator = node[keyPath: contentsKeyPath].makeIterator()
@@ -2796,7 +2796,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   ) -> Bool where BodyContents.Element == Syntax {
     // If the collection is empty, then any comments that might be present in the block must be
     // leading trivia of the right brace.
-    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.numberOfComments > 0
+    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.hasAnyComments
     // We can't use `count` here because it also includes missing children. Instead, we get an
     // iterator and check if it returns `nil` immediately.
     var contentsIterator = node[keyPath: contentsKeyPath].makeIterator()
@@ -2817,7 +2817,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   ) -> Bool where BodyContents.Element == DeclSyntax {
     // If the collection is empty, then any comments that might be present in the block must be
     // leading trivia of the right brace.
-    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.numberOfComments > 0
+    let commentPrecedesRightBrace = node.rightBrace.leadingTrivia.hasAnyComments
     // We can't use `count` here because it also includes missing children. Instead, we get an
     // iterator and check if it returns `nil` immediately.
     var contentsIterator = node[keyPath: contentsKeyPath].makeIterator()
@@ -2980,7 +2980,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
   private func arrangeBracesAndContents(leftBrace: TokenSyntax, accessors: AccessorDeclListSyntax, rightBrace: TokenSyntax) {
     // If the collection is empty, then any comments that might be present in the block must be
     // leading trivia of the right brace.
-    let commentPrecedesRightBrace = rightBrace.leadingTrivia.numberOfComments > 0
+    let commentPrecedesRightBrace = rightBrace.leadingTrivia.hasAnyComments
     // We can't use `count` here because it also includes missing children. Instead, we get an
     // iterator and check if it returns `nil` immediately.
     var accessorsIterator = accessors.makeIterator()
@@ -3890,10 +3890,13 @@ class CommentMovingRewriter: SyntaxRewriter {
   }
 
   override func visit(_ token: TokenSyntax) -> TokenSyntax {
-    if let rewrittenTrivia = rewriteTokenTriviaMap[token] {
-      return token.with(\.leadingTrivia, rewrittenTrivia)
+    guard let rewrittenTrivia = rewriteTokenTriviaMap[token] else {
+      return token
     }
-    return token
+
+    var result = token
+    result.leadingTrivia = rewrittenTrivia
+    return result
   }
 
   override func visit(_ node: InfixOperatorExprSyntax) -> ExprSyntax {

Sources/SwiftFormat/PrettyPrint/TokenStreamCreator.swift

@@ -73,11 +73,11 @@ public final class AllPublicDeclarationsHaveDocumentation: SyntaxLintRule {
   private func diagnoseMissingDocComment(
     _ decl: DeclSyntax,
     name: String,
-    modifiers: DeclModifierListSyntax?
+    modifiers: DeclModifierListSyntax
   ) {
     guard
       DocumentationCommentText(extractedFrom: decl.leadingTrivia) == nil,
-      let mods = modifiers, mods.has(modifier: "public") && !mods.has(modifier: "override")
+      modifiers.contains(anyOf: [.public, .override])
     else {
       return
     }

Sources/SwiftFormat/Rules/AllPublicDeclarationsHaveDocumentation.swift

@@ -46,7 +46,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
     // Don't diagnose any issues when the variable is overriding, because this declaration can't
     // rename the variable. If the user analyzes the code where the variable is really declared,
     // then the diagnostic can be raised for just that location.
-    if node.modifiers.has(modifier: "override") {
+    if node.modifiers.contains(anyOf: [.override]) {
       return .visitChildren
     }
 
@@ -114,7 +114,7 @@ public final class AlwaysUseLowerCamelCase: SyntaxLintRule {
     // Don't diagnose any issues when the function is overriding, because this declaration can't
     // rename the function. If the user analyzes the code where the function is really declared,
     // then the diagnostic can be raised for just that location.
-    if node.modifiers.has(modifier: "override") {
+    if node.modifiers.contains(anyOf: [.override]) {
       return .visitChildren
     }
 

Sources/SwiftFormat/Rules/AlwaysUseLowerCamelCase.swift

@@ -42,7 +42,7 @@ public final class AmbiguousTrailingClosureOverload: SyntaxLintRule {
       let params = fn.signature.parameterClause.parameters
       guard let firstParam = params.firstAndOnly else { continue }
       guard firstParam.type.is(FunctionTypeSyntax.self) else { continue }
-      if fn.modifiers.has(modifier: "static") || fn.modifiers.has(modifier: "class") {
+      if fn.modifiers.contains(anyOf: [.class, .static]) {
         staticOverloads[fn.name.text, default: []].append(fn)
       } else {
         overloads[fn.name.text, default: []].append(fn)

Sources/SwiftFormat/Rules/AmbiguousTrailingClosureOverload.swift

@@ -28,7 +28,7 @@ public final class DoNotUseSemicolons: SyntaxFormatRule {
   ///   - node: A node that contains items which may have semicolons or nested code blocks.
   ///   - nodeCreator: A closure that creates a new node given an array of items.
   private func nodeByRemovingSemicolons<
-    ItemType: SyntaxProtocol & SemicolonSyntaxProtocol & Equatable, NodeType: SyntaxCollection
+    ItemType: SyntaxProtocol & WithSemicolonSyntax & Equatable, NodeType: SyntaxCollection
   >(from node: NodeType, nodeCreator: ([ItemType]) -> NodeType) -> NodeType
   where NodeType.Element == ItemType {
     var newItems = Array(node)
@@ -84,7 +84,7 @@ public final class DoNotUseSemicolons: SyntaxFormatRule {
         // whitespace, and the pretty printer adds any necessary spaces so it's safe to discard.
         // TODO: When we stop using the legacy trivia transform, we need to fix this to preserve
         // trailing comments.
-        newItem = newItem.with(\.semicolon, nil)
+        newItem.semicolon = nil
 
         // When emitting the finding, tell the user to move the next statement down if there is
         // another statement following this one. Otherwise, just tell them to remove the semicolon.