Consolidate some fairly specialized helpers.

These were only used in one place and have implementations that are
pretty specific to just the calling rule, so move them side-by-side
with that rule and make them file-private.

Author: allevato

Sources/SwiftFormat/Core/AddModifierRewriter.swift

@@ -46,7 +46,6 @@ extension DeclModifierListSyntax {
     }
   }
 
-
   /// 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 {
@@ -56,30 +55,4 @@ extension DeclModifierListSyntax {
       }
     }
   }
-
-  /// Inserts the given modifier into the list at a specific index.
-  ///
-  /// If the modifier is being inserted at the front of the list, the current front element's
-  /// leading trivia will be moved to the new element to preserve any leading comments and newlines.
-  mutating func triviaPreservingInsert(
-    _ modifier: DeclModifierSyntax, at index: SyntaxChildrenIndex
-  ) {
-    var modifier = modifier
-    modifier.trailingTrivia = [.spaces(1)]
-
-    guard index == self.startIndex else {
-      self.insert(modifier, at: index)
-      return
-    }
-    guard var firstMod = first, let firstTok = firstMod.firstToken(viewMode: .sourceAccurate) else {
-      self.insert(modifier, at: index)
-      return
-    }
-
-    modifier.leadingTrivia = firstTok.leadingTrivia
-    firstMod.leadingTrivia = []
-    firstMod.trailingTrivia = [.spaces(1)]
-    self[self.startIndex] = firstMod
-    self.insert(modifier, at: self.startIndex)
-  }
 }

Sources/SwiftFormat/Core/ModifierListSyntax+Convenience.swift

@@ -71,40 +71,35 @@ public final class NoAccessLevelOnExtensionDeclaration: SyntaxFormatRule {
 
   // Adds given keyword to all members in declaration block
   private func addMemberAccessKeyword(
-    _ keyword: DeclModifierSyntax,
+    _ modifier: DeclModifierSyntax,
     toMembersIn memberBlock: MemberBlockSyntax
   ) -> (MemberBlockItemListSyntax, [Finding.Note]) {
     var newMembers: [MemberBlockItemSyntax] = []
     var notes: [Finding.Note] = []
 
-    var formattedKeyword = keyword
-    formattedKeyword.leadingTrivia = []
-
     for memberItem in memberBlock.members {
-      let member = memberItem.decl
+      let decl = memberItem.decl
       guard
-        let modifiers = member.asProtocol(WithModifiersSyntax.self)?.modifiers,
-        // addModifier relocates trivia for any token(s) displaced by the new modifier.
-        let newDecl = addModifier(declaration: member, modifierKeyword: formattedKeyword)
-          .as(DeclSyntax.self)
+        let modifiers = decl.asProtocol(WithModifiersSyntax.self)?.modifiers,
+        modifiers.accessLevelModifier == nil
       else {
         newMembers.append(memberItem)
         continue
       }
 
+      // Create a note associated with each declaration that needs to have an access level modifier
+      // added to it.
+      notes.append(Finding.Note(
+        message: .addModifierToExtensionMember(keyword: modifier.name.text),
+        location:
+          Finding.Location(decl.startLocation(converter: context.sourceLocationConverter))
+      ))
+
       var newItem = memberItem
-      newItem.decl = newDecl
+      newItem.decl = applyingAccessModifierIfNone(modifier, to: decl)
       newMembers.append(newItem)
-
-      // If it already had an explicit access modifier, don't leave a note.
-      if modifiers.accessLevelModifier == nil {
-        notes.append(Finding.Note(
-          message: .addModifierToExtensionMember(keyword: formattedKeyword.name.text),
-          location:
-            Finding.Location(member.startLocation(converter: context.sourceLocationConverter))
-        ))
-      }
     }
+
     return (MemberBlockItemListSyntax(newMembers), notes)
   }
 }
@@ -129,3 +124,69 @@ extension Finding.Message {
     "add '\(keyword)' access modifier to this declaration"
   }
 }
+
+/// Adds `modifier` to `decl` if it doesn't already have an explicit access level modifier and
+/// returns the new declaration.
+///
+/// If `decl` already has an access level modifier, it is returned unchanged.
+private func applyingAccessModifierIfNone(
+  _ modifier: DeclModifierSyntax,
+  to decl: DeclSyntax
+) -> DeclSyntax {
+  switch Syntax(decl).as(SyntaxEnum.self) {
+  case .actorDecl(let actorDecl):
+    return applyingAccessModifierIfNone(modifier, to: actorDecl, declKeywordKeyPath: \.actorKeyword)
+  case .classDecl(let classDecl):
+    return applyingAccessModifierIfNone(modifier, to: classDecl, declKeywordKeyPath: \.classKeyword)
+  case .enumDecl(let enumDecl):
+    return applyingAccessModifierIfNone(modifier, to: enumDecl, declKeywordKeyPath: \.enumKeyword)
+  case .initializerDecl(let initDecl):
+    return applyingAccessModifierIfNone(modifier, to: initDecl, declKeywordKeyPath: \.initKeyword)
+  case .functionDecl(let funcDecl):
+    return applyingAccessModifierIfNone(modifier, to: funcDecl, declKeywordKeyPath: \.funcKeyword)
+  case .structDecl(let structDecl):
+    return applyingAccessModifierIfNone(
+      modifier, to: structDecl, declKeywordKeyPath: \.structKeyword)
+  case .subscriptDecl(let subscriptDecl):
+    return applyingAccessModifierIfNone(
+      modifier, to: subscriptDecl, declKeywordKeyPath: \.subscriptKeyword)
+  case .typeAliasDecl(let typeAliasDecl):
+    return applyingAccessModifierIfNone(
+      modifier, to: typeAliasDecl, declKeywordKeyPath: \.typealiasKeyword)
+  case .variableDecl(let varDecl):
+    return applyingAccessModifierIfNone(
+      modifier, to: varDecl, declKeywordKeyPath: \.bindingSpecifier)
+  default:
+    return decl
+  }
+}
+
+private func applyingAccessModifierIfNone<Decl: DeclSyntaxProtocol & WithModifiersSyntax>(
+  _ modifier: DeclModifierSyntax,
+  to decl: Decl,
+  declKeywordKeyPath: WritableKeyPath<Decl, TokenSyntax>
+) -> DeclSyntax {
+  // If there's already an access modifier among the modifier list, bail out.
+  guard decl.modifiers.accessLevelModifier == nil else { return DeclSyntax(decl) }
+
+  var result = decl
+  var modifier = modifier
+  modifier.trailingTrivia = [.spaces(1)]
+
+  guard var firstModifier = decl.modifiers.first else {
+    // If there are no modifiers at all, add the one being requested, moving the leading trivia
+    // from the decl keyword to that modifier (to preserve leading comments, newlines, etc.).
+    modifier.leadingTrivia = decl[keyPath: declKeywordKeyPath].leadingTrivia
+    result[keyPath: declKeywordKeyPath].leadingTrivia = []
+    result.modifiers = .init([modifier])
+    return DeclSyntax(result)
+  }
+
+  // Otherwise, insert the modifier at the front of the modifier list, moving the (original) first
+  // modifier's leading trivia to the new one (to preserve leading comments, newlines, etc.).
+  modifier.leadingTrivia = firstModifier.leadingTrivia
+  firstModifier.leadingTrivia = []
+  result.modifiers[result.modifiers.startIndex] = firstModifier
+  result.modifiers.insert(modifier, at: result.modifiers.startIndex)
+  return DeclSyntax(result)
+}