Implement FullyIndirectEnum rule and tests. (swiftlang#55)

Author: LaurenWhite

Sources/Rules/FullyIndirectEnum.swift

@@ -1,3 +1,4 @@
+
 import Core
 import Foundation
 import SwiftSyntax
@@ -12,5 +13,97 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#enum-cases
 public final class FullyIndirectEnum: SyntaxFormatRule {
+  public override func visit(_ node: EnumDeclSyntax) -> DeclSyntax {
+
+    let enumMembers = node.members.members
+    guard allAreIndirectCases(members: enumMembers) else { return node }
+    diagnose(.reassignIndirectKeyword(name: node.identifier.text), on: node.identifier)
+
+    // Removes 'indirect' keyword from cases, reformats
+    var newMembers: [MemberDeclListItemSyntax] = []
+    for member in enumMembers {
+      if let caseMember = member.decl as? EnumCaseDeclSyntax {
+        guard let caseModifiers = caseMember.modifiers else { continue }
+        guard let firstModifier = caseModifiers.first else { continue }
+        let newCase = caseMember.withModifiers(removeIndirectModifier(curModifiers: caseModifiers))
+        let formattedCase = formatCase(unformattedCase: newCase,
+                                       leadingTrivia: firstModifier.leadingTrivia)
+        let newMember = SyntaxFactory.makeMemberDeclListItem(decl: formattedCase, semicolon: nil)
+        newMembers.append(newMember)
+      } else {
+        newMembers.append(member)
+      }
+    }
+
+    let members = SyntaxFactory.makeMemberDeclList(newMembers)
+    let newMemberBlock = SyntaxFactory.makeMemberDeclBlock(leftBrace: node.members.leftBrace,
+                                                           members: members,
+                                                           rightBrace: node.members.rightBrace)
+
+    // Format indirect keyword and following token, if necessary
+    guard let firstTok = node.firstToken else { return node }
+    var leadingTrivia: Trivia = []
+    var newDecl = node
+    if firstTok.tokenKind == .enumKeyword {
+      leadingTrivia = firstTok.leadingTrivia
+      newDecl = replaceTrivia(on: node,
+                              token: node.firstToken,
+                              leadingTrivia: []) as! EnumDeclSyntax
+    }
+
+    let newModifier = SyntaxFactory.makeDeclModifier(
+                      name: SyntaxFactory.makeIdentifier("indirect",
+                                                         leadingTrivia: leadingTrivia,
+                                                         trailingTrivia: .spaces(1)),
+                      detailLeftParen: nil, detail: nil, detailRightParen: nil)
+
+    return newDecl.addModifier(newModifier).withMembers(newMemberBlock)
+  }
+
+  // Determines if all given cases are indirect
+  func allAreIndirectCases(members: MemberDeclListSyntax) -> Bool {
+    for member in members {
+      if let caseMember = member.decl as? EnumCaseDeclSyntax {
+        guard let caseModifiers = caseMember.modifiers else { return false }
+        if isIndirectCase(modifiers: caseModifiers) { continue }
+        else { return false }
+      }
+    }
+    return true
+  }
+
+  func isIndirectCase(modifiers: ModifierListSyntax) -> Bool {
+    for modifier in modifiers {
+      if modifier.name.tokenKind == .identifier("indirect") { return true }
+    }
+    return false
+  }
+
+  func removeIndirectModifier(curModifiers: ModifierListSyntax) -> ModifierListSyntax {
+    var newMods: [DeclModifierSyntax] = []
+      for modifier in curModifiers {
+        if modifier.name.tokenKind != .identifier("indirect") { newMods.append(modifier) }
+      }
+    return SyntaxFactory.makeModifierList(newMods)
+  }
+
+  // Transfers given leading trivia to the first token in the case declaration
+  func formatCase(unformattedCase: EnumCaseDeclSyntax,
+                  leadingTrivia: Trivia?) -> EnumCaseDeclSyntax {
+    if let modifiers = unformattedCase.modifiers, let first = modifiers.first {
+      return replaceTrivia(on: unformattedCase,
+                           token: first.firstToken,
+                           leadingTrivia: leadingTrivia) as! EnumCaseDeclSyntax
+    } else {
+      return replaceTrivia(on: unformattedCase,
+                           token: unformattedCase.caseKeyword,
+                           leadingTrivia: leadingTrivia) as! EnumCaseDeclSyntax
+    }
+  }
+}
 
+extension Diagnostic.Message {
+  static func reassignIndirectKeyword(name: String) -> Diagnostic.Message {
+    return .init(.warning, "move 'indirect' to \(name) enum declaration")
+  }
 }

Tests/SwiftFormatTests/FullyIndirectEnumTests.swift

@@ -0,0 +1,45 @@
+import Foundation
+import XCTest
+import SwiftSyntax
+
+@testable import Rules
+
+public class FullyIndirectEnumTests: DiagnosingTestCase {
+  public func testIndirectEnumReassignment() {
+    XCTAssertFormatting(
+      FullyIndirectEnum.self,
+      input: """
+             // Comment 1
+             public enum DependencyGraphNode {
+               internal indirect case userDefined(dependencies: [DependencyGraphNode])
+               // Comment 2
+               indirect case synthesized(dependencies: [DependencyGraphNode])
+               indirect case other(dependencies: [DependencyGraphNode])
+               var x: Int
+             }
+             public enum CompassPoint {
+               case north
+               indirect case south
+               case east
+               case west
+             }
+             """,
+      expected: """
+                // Comment 1
+                public indirect enum DependencyGraphNode {
+                  internal case userDefined(dependencies: [DependencyGraphNode])
+                  // Comment 2
+                  case synthesized(dependencies: [DependencyGraphNode])
+                  case other(dependencies: [DependencyGraphNode])
+                  var x: Int
+                }
+                public enum CompassPoint {
+                  case north
+                  indirect case south
+                  case east
+                  case west
+                }
+                """
+    )
+  }
+}