Implement use synthesized initializer. (swiftlang#87)

LaurenWhite · allevato · commit 8da26cea08be · 2018-09-17T13:40:39.000-07:00
diff --git a/Sources/Rules/ModifierListSyntax+Convenience.swift b/Sources/Rules/ModifierListSyntax+Convenience.swift
@@ -1,7 +1,85 @@
 import SwiftSyntax
 
 extension ModifierListSyntax {
+
   func has(modifier: String) -> Bool {
     return contains { $0.name.text == modifier }
   }
+
+  /// Returns the declaration's access level modifier, if present.
+  var accessLevelModifier: DeclModifierSyntax? {
+    for modifier in self {
+      switch modifier.name.tokenKind {
+      case .publicKeyword, .privateKeyword, .fileprivateKeyword, .internalKeyword:
+        return modifier
+      default:
+        continue
+      }
+    }
+    return nil
+  }
+
+  /// Returns modifier list without the given modifier.
+  func remove(name: String) -> ModifierListSyntax {
+    guard has(modifier: name) else { return self }
+    for mod in self {
+      if mod.name.text == name {
+        return removing(childAt: mod.indexInParent)
+      }
+    }
+    return self
+  }
+
+  /// Returns a foramatted declaration modifier token with the given name.
+  func createModifierToken(name: String) -> DeclModifierSyntax {
+    let id = SyntaxFactory.makeIdentifier(name, trailingTrivia: .spaces(1))
+    let newModifier = SyntaxFactory.makeDeclModifier(name: id,
+                      detailLeftParen: nil, detail: nil, detailRightParen: nil)
+    return newModifier
+  }
+  
+  /// Returns modifiers with the given modifier inserted at the given index.
+  /// Preserves existing trivia and formats new trivia, given true for 'formatTrivia.'
+  func insert(modifier: DeclModifierSyntax, at index: Int,
+              formatTrivia: Bool = true) -> ModifierListSyntax {
+    guard index >= 0, index <= count else { return self }
+
+    var newModifiers: [DeclModifierSyntax] = []
+    newModifiers.append(contentsOf: self)
+
+    let modifier = formatTrivia ?
+                     replaceTrivia(on: modifier,
+                                   token: modifier.name,
+                                   trailingTrivia: .spaces(1)) as! DeclModifierSyntax : modifier
+
+    if index == 0 {
+      guard formatTrivia else { return inserting(modifier, at: index) }
+      guard let firstMod = first, let firstTok = firstMod.firstToken else {
+        return inserting(modifier, at: index)
+      }
+      let formattedMod = replaceTrivia(on: modifier,
+                                       token: modifier.firstToken,
+                                       leadingTrivia: firstTok.leadingTrivia) as! DeclModifierSyntax
+      newModifiers[0] = replaceTrivia(on: firstMod,
+                                      token: firstTok,
+                                      leadingTrivia: [],
+                                      trailingTrivia: .spaces(1)) as! DeclModifierSyntax
+      newModifiers.insert(formattedMod, at: 0)
+      return SyntaxFactory.makeModifierList(newModifiers)
+    } else {
+      return inserting(modifier, at: index)
+    }
+  }
+
+  /// Returns modifier list with the given modifier at the end.
+  /// Trivia manipulation optional by 'formatTrivia'
+  func append(modifier: DeclModifierSyntax, formatTrivia: Bool = true) -> ModifierListSyntax {
+    return insert(modifier: modifier, at: count, formatTrivia: formatTrivia)
+  }
+
+  /// Returns modifier list with the given modifier at the beginning.
+  /// Trivia manipulation optional by 'formatTrivia'
+  func prepend(modifier: DeclModifierSyntax, formatTrivia: Bool = true) -> ModifierListSyntax {
+    return insert(modifier: modifier, at: 0, formatTrivia: formatTrivia)
+  }
 }
diff --git a/Sources/Rules/UseSynthesizedInitializer.swift b/Sources/Rules/UseSynthesizedInitializer.swift
@@ -12,5 +12,109 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#initializers-2
 public final class UseSynthesizedInitializer: SyntaxLintRule {
+  public override func visit(_ node: StructDeclSyntax) {
+    var storedProperties: [VariableDeclSyntax] = []
+    var initializers: [InitializerDeclSyntax] = []
 
+    for member in node.members.members {
+      // Collect all stored variables into a list
+      if let varDecl = member.decl as? VariableDeclSyntax {
+        guard let modifiers = varDecl.modifiers else {
+          storedProperties.append(varDecl)
+          continue
+        }
+        guard !modifiers.has(modifier: "static") else { continue }
+        storedProperties.append(varDecl)
+      // Collect any possible redundant initializers into a list
+      } else if let initDecl = member.decl as? InitializerDeclSyntax {
+        guard initDecl.modifiers == nil ||
+              initDecl.modifiers!.has(modifier: "internal") else { continue }
+        guard initDecl.optionalMark == nil else { continue }
+        guard initDecl.throwsOrRethrowsKeyword == nil else { continue }
+        initializers.append(initDecl)
+      }
+    }
+
+    for initializer in initializers {
+      guard matchesPropertyList(parameters: initializer.parameters.parameterList,
+                                properties: storedProperties) else { continue }
+      guard matchesAssignmentBody(variables: storedProperties,
+                                  initBody: initializer.body) else { continue }
+      diagnose(.removeRedundantInitializer, on: initializer)
+    }
+  }
+
+  // Compares initializer parameters to stored properties of the struct
+  func matchesPropertyList(parameters: FunctionParameterListSyntax,
+                            properties: [VariableDeclSyntax]) -> Bool {
+    guard parameters.count == properties.count else { return false }
+    for (idx, parameter) in parameters.enumerated() {
+
+      guard let paramId = parameter.firstName, parameter.secondName == nil else { return false }
+      guard let paramType = parameter.type else { return false }
+
+      let property = properties[idx]
+      let propertyId = property.firstIdentifier
+      guard let propertyType = property.firstType else { return false }
+
+      // Sythesized initializer only keeps default argument if the declaration uses 'var'
+      if property.letOrVarKeyword.tokenKind == .varKeyword {
+        if let initializer = property.firstInitializer {
+          guard let defaultArg = parameter.defaultArgument else { return false }
+          guard initializer.value.description == defaultArg.value.description else { return false }
+        }
+      }
+
+      if propertyId.identifier.text != paramId.text ||
+         propertyType.description.trimmingCharacters(in: .whitespaces) !=
+          paramType.description.trimmingCharacters(in: .whitespacesAndNewlines) { return false }
+    }
+    return true
+  }
+
+  // Evaluates if all, and only, the stored properties are initialized in the body
+  func matchesAssignmentBody(variables: [VariableDeclSyntax],
+                             initBody: CodeBlockSyntax?) -> Bool {
+    guard let initBody = initBody else { return false }
+    guard variables.count == initBody.statements.count else { return false }
+
+    var statements: [String] = []
+    for statement in initBody.statements {
+      guard let exp = statement.item as? SequenceExprSyntax else { return false }
+      var leftName = ""
+      var rightName = ""
+
+      for element in exp.elements {
+        switch element {
+        case let element as MemberAccessExprSyntax:
+          guard let base = element.base else { return false }
+          guard base.description.trimmingCharacters(in: .whitespacesAndNewlines) == "self" else {
+            return false
+          }
+          leftName = element.name.text
+        case let element as AssignmentExprSyntax:
+          guard element.assignToken.tokenKind == .equal else { return false }
+        case let element as IdentifierExprSyntax:
+          rightName = element.identifier.text
+        default:
+          return false
+        }
+      }
+      guard leftName == rightName else { return false }
+      statements.append(leftName)
+    }
+
+    for variable in variables {
+      let id = variable.firstIdentifier.identifier.text
+      guard statements.contains(id) else { return false }
+      guard let idx = statements.firstIndex(of: id) else { return false }
+      statements.remove(at: idx)
+    }
+    return statements.isEmpty
+  }
+}
+
+extension Diagnostic.Message {
+  static let removeRedundantInitializer = Diagnostic.Message(.warning,
+                                           "initializer is the same as synthesized initializer")
 }
diff --git a/Sources/Rules/VarDeclSyntax+Convenience.swift b/Sources/Rules/VarDeclSyntax+Convenience.swift
@@ -0,0 +1,29 @@
+import SwiftSyntax
+
+extension VariableDeclSyntax {
+
+  /// Returns array of all identifiers listed in the declaration.
+  var identifiers: [IdentifierPatternSyntax] {
+    var ids: [IdentifierPatternSyntax] = []
+    for binding in bindings {
+      guard let id = binding.pattern as? IdentifierPatternSyntax else { continue }
+      ids.append(id)
+    }
+    return ids
+  }
+
+  /// Returns the first identifier.
+  var firstIdentifier: IdentifierPatternSyntax {
+    return identifiers[0]
+  }
+
+  /// Returns the first type explicitly stated in the declaration, if present.
+  var firstType: TypeSyntax? {
+    return bindings.first?.typeAnnotation?.type
+  }
+
+  /// Returns the first initializer clause, if present.
+  var firstInitializer: InitializerClauseSyntax? {
+    return bindings.first?.initializer
+  }
+}
diff --git a/Tests/SwiftFormatTests/UseSynthesizedInitializerTests.swift b/Tests/SwiftFormatTests/UseSynthesizedInitializerTests.swift
@@ -0,0 +1,60 @@
+import Foundation
+import SwiftSyntax
+import XCTest
+
+@testable import Rules
+
+public class UseSynthesizedInitializerTests: DiagnosingTestCase {
+  public func testRedundantCustomInitializer() {
+    let input =
+      """
+      public struct Person {
+
+        public var name: String = "John Doe"
+        let phoneNumber: String?
+        private let address: String = "123 Happy St"
+
+        init(name: String = "John Doe", phoneNumber: String?, address: String) {
+          self.name = name
+          self.address = address
+          self.phoneNumber = phoneNumber
+        }
+
+        init(name: String, phoneNumber: String?, address: String) {
+          self.name = name
+          self.phoneNumber = "1234578910"
+          self.address = address
+        }
+        init(name: String, phoneNumber: String? = "123456789", address: String) {
+          self.name = name
+          self.phoneNumber = phoneNumber
+          self.address = address
+        }
+        public init(name: String, phoneNumber: String?, address: String) {
+          self.name = name
+          self.phoneNumber = phoneNumber
+          self.address = address
+        }
+        init?(name: String, phoneNumber: String?, address: String) {
+          self.name = name
+          self.phoneNumber = phoneNumber
+          self.address = address
+        }
+        init(name: String, phoneNumber: String?, address: String) throws {
+          self.name = name
+          self.phoneNumber = phoneNumber
+          self.address = address
+        }
+      }
+      """
+    performLint(UseSynthesizedInitializer.self, input: input)
+    XCTAssertDiagnosed(.removeRedundantInitializer)
+    XCTAssertNotDiagnosed(.removeRedundantInitializer)
+  }
+  
+  #if !os(macOS)
+  static let allTests = [
+    UseSynthesizedInitializerTests.testRedundantCustomInitializer,
+    ]
+  #endif
+}
