Implement one case per line (swiftlang#59)

Author: LaurenWhite

tools/swift-format/Sources/Rules/OneCasePerLine.swift

@@ -11,5 +11,89 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#enum-cases
 public final class OneCasePerLine: SyntaxFormatRule {
+  
+  public override func visit(_ node: EnumDeclSyntax) -> DeclSyntax {
+    let enumMembers = node.members.members
+    var newMembers: [MemberDeclListItemSyntax] = []
+    var newIndx = 0
+    
+    for member in enumMembers {
+      var numNewMembers = 0
+      if let caseMember = member.decl as? EnumCaseDeclSyntax {
+        var otherDecl: EnumCaseDeclSyntax? = caseMember
+        // Add and skip single element case declarations
+        guard caseMember.elements.count > 1 else {
+            let newMember = SyntaxFactory.makeMemberDeclListItem(decl: caseMember, semicolon: nil)
+            newMembers.append(newMember)
+            newIndx += 1
+            continue
+        }
+        // Move all cases with associated/raw values to new declarations
+        for element in caseMember.elements {
+          if element.associatedValue != nil || element.rawValue != nil {
+            diagnose(.moveAssociatedOrRawValueCase(name: element.identifier.text), on: element)
+            let newRemovedDecl = createAssociateOrRawCaseDecl(fullDecl: caseMember,
+                                                              removedElement: element)
+            otherDecl = removeAssociateOrRawCaseDecl(fullDecl: otherDecl)
+            let newMember = SyntaxFactory.makeMemberDeclListItem(decl: newRemovedDecl,
+                                                                 semicolon: nil)
+            newMembers.append(newMember)
+            numNewMembers += 1
+          }
+        }
+        // Add case declaration of remaining elements without associated/raw values, if any
+        if let otherDecl = otherDecl {
+          let newMember = SyntaxFactory.makeMemberDeclListItem(decl: otherDecl, semicolon: nil)
+          newMembers.insert(newMember, at: newIndx)
+          newIndx += 1
+        }
+      // Add any member that isn't an enum case declaration
+      } else {
+        newMembers.append(member)
+        newIndx += 1
+      }
+      newIndx += numNewMembers
+    }
 
+    let newDeclList = SyntaxFactory.makeMemberDeclList(newMembers)
+    let newMemberBlock = SyntaxFactory.makeMemberDeclBlock(leftBrace: node.members.leftBrace,
+                                                           members: newDeclList,
+                                                           rightBrace: node.members.rightBrace)
+    return node.withMembers(newMemberBlock)
+  }
+  
+  func createAssociateOrRawCaseDecl(fullDecl: EnumCaseDeclSyntax,
+                                    removedElement: EnumCaseElementSyntax) -> EnumCaseDeclSyntax {
+    let formattedElement = removedElement.withTrailingComma(nil)
+    let newElementList = SyntaxFactory.makeEnumCaseElementList([formattedElement])
+    let newDecl = SyntaxFactory.makeEnumCaseDecl(attributes: fullDecl.attributes,
+                                                 modifiers: fullDecl.modifiers,
+                                                 caseKeyword: fullDecl.caseKeyword,
+                                                 elements: newElementList)
+    return newDecl
+  }
+
+  // Returns formatted declaration of cases without associated/raw values, or nil if all cases had
+  // a raw or associate value
+  func removeAssociateOrRawCaseDecl(fullDecl: EnumCaseDeclSyntax?) -> EnumCaseDeclSyntax? {
+    guard let fullDecl = fullDecl else { return nil }
+    var newList: [EnumCaseElementSyntax] = []
+
+    for element in fullDecl.elements {
+      if element.associatedValue == nil && element.rawValue == nil { newList.append(element) }
+    }
+
+    guard newList.count > 0 else { return nil }
+    let (last, indx) = (newList[newList.count - 1], newList.count - 1)
+    if last.trailingComma != nil {
+      newList[indx] = last.withTrailingComma(nil)
+    }
+    return fullDecl.withElements(SyntaxFactory.makeEnumCaseElementList(newList))
+  }
+}
+
+extension Diagnostic.Message {
+  static func moveAssociatedOrRawValueCase(name: String) -> Diagnostic.Message {
+    return .init(.warning, "move \(name) case to a new line")
+  }
 }

tools/swift-format/Tests/SwiftFormatTests/OneCasePerLineTests.swift

@@ -0,0 +1,45 @@
+import Foundation
+import XCTest
+import SwiftSyntax
+
+@testable import Rules
+
+public class OneCasePerLineTests: DiagnosingTestCase {
+  func testInvalidCasesOnLine() {
+    XCTAssertFormatting(OneCasePerLine.self,
+                        input: """
+                               public enum Token {
+                                 case arrow
+                                 case comma, identifier(String), semicolon, stringSegment(String)
+                                 case period
+                                 case ifKeyword(String), forKeyword(String)
+                                 indirect case guardKeyword, elseKeyword, contextualKeyword(String)
+                                 var x: Bool
+                                 case leftParen, rightParen = ")", leftBrace, rightBrace = "}"
+                               }
+                               """,
+                        expected: """
+                                  public enum Token {
+                                    case arrow
+                                    case comma, semicolon
+                                    case identifier(String)
+                                    case stringSegment(String)
+                                    case period
+                                    case ifKeyword(String)
+                                    case forKeyword(String)
+                                    indirect case guardKeyword, elseKeyword
+                                    indirect case contextualKeyword(String)
+                                    var x: Bool
+                                    case leftParen, leftBrace
+                                    case rightParen = ")"
+                                    case rightBrace = "}"
+                                  }
+                                  """)
+  }
+  
+  #if !os(macOS)
+  static let allTests = [
+    OneCasePerLineTests.testInvalidCasesOnLine,
+    ]
+  #endif
+}