Merge pull request swiftlang#177 from dabelknap/initializer-literals

Correct the behavior of AvoidInitializersForLiterals

Author: allevato

Sources/SwiftFormatRules/AvoidInitializersForLiterals.swift

@@ -25,53 +25,35 @@ fileprivate let knownIntTypes = Set(intSizes.map { "Int\($0)" } + intSizes.map {
 /// Lint: If an initializer-style cast is used on a built-in type known to be expressible by
 ///       that kind of literal type, a lint error is raised.
 ///
-/// Format: Initializer-style casts between known built-in types will be converted to standard
-///         casts.
-///
 /// - SeeAlso: https://google.github.io/swift#numeric-and-string-literals
-public final class AvoidInitializersForLiterals: SyntaxFormatRule {
-  public override func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax {
+public final class AvoidInitializersForLiterals: SyntaxLintRule {
+  public override func visit(_ node: FunctionCallExprSyntax) {
     // Ensure we're calling a known Integer initializer.
     guard let callee = node.calledExpression as? IdentifierExprSyntax else {
       // Ensure we properly visit the children of this node, in case we have other function calls
       // as parameters to this one.
       return super.visit(node)
     }
 
-    let typeName = callee.identifier.text
-
-    guard let literal = extractLiteral(node, typeName) else {
+    guard node.argumentList.count == 1 else {
       return super.visit(node)
     }
 
-    diagnose(.avoidInitializerStyleCast, on: callee) {
-      $0.highlight(callee.sourceRange(in: self.context.fileURL))
+    for arg in node.argumentList {
+      if arg.label != nil {
+        return super.visit(node)
+      }
     }
 
-    // Construct an 'as' cast, converting `X(y)` to `y as X`.
-    let asExpr = AsExprSyntax {
-      $0.useAsTok(SyntaxFactory.makeAsKeyword(
-        trailingTrivia: .spaces(1)
-      ))
-      $0.useTypeName(
-        SyntaxFactory.makeSimpleTypeIdentifier(
-          name: callee.identifier,
-          genericArgumentClause: nil
-        )
-      )
-    }
+    let typeName = callee.identifier.text
 
-    let newLiteral = replaceTrivia(
-      on: literal,
-      token: literal.firstToken,
-      trailingTrivia: .spaces(1)
-    ) as! ExprSyntax
+    guard let _ = extractLiteral(node, typeName) else {
+      return super.visit(node)
+    }
 
-    return SyntaxFactory.makeSequenceExpr(
-      elements: SyntaxFactory.makeExprList([
-        newLiteral,
-        asExpr,
-      ]))
+    diagnose(.avoidInitializerStyleCast(node.description), on: callee) {
+      $0.highlight(callee.sourceRange(in: self.context.fileURL))
+    }
   }
 }
 
@@ -89,6 +71,7 @@ fileprivate func extractLiteral(_ node: FunctionCallExprSyntax, _ typeName: Stri
 }
 
 extension Diagnostic.Message {
-  static let avoidInitializerStyleCast =
-    Diagnostic.Message(.warning, "change initializer call with literal argument to an 'as' cast")
+  static func avoidInitializerStyleCast(_ name: String) -> Diagnostic.Message {
+    return .init(.warning, "change initializer call '\(name)' with literal argument to an 'as' cast")
+  }
 }

Sources/swift-format/PopulatePipeline.swift

@@ -27,12 +27,6 @@ func populate(_ pipeline: Pipeline) {
 
   /// MARK: Formatting Passes
 
-  pipeline.addFormatter(
-    AvoidInitializersForLiterals.self,
-    for:
-      FunctionCallExprSyntax.self
-  )
-
   pipeline.addFormatter(
     BlankLineBetweenMembers.self,
     for:
@@ -266,6 +260,12 @@ func populate(_ pipeline: Pipeline) {
       SourceFileSyntax.self
   )
 
+  pipeline.addLinter(
+    AvoidInitializersForLiterals.self,
+    for:
+      FunctionCallExprSyntax.self
+  )
+
   pipeline.addLinter(
     BeginDocumentationCommentWithOneLineSummary.self,
     for:

Tests/SwiftFormatRulesTests/AvoidInitializersForLiteralsTests.swift

@@ -5,24 +5,27 @@ import XCTest
 
 public class AvoidInitializersForLiteralsTests: DiagnosingTestCase {
   public func testInitializersForLiterals() {
-    XCTAssertFormatting(
-      AvoidInitializersForLiterals.self,
-      input: """
-             let v1 = UInt32(76)
-             let v2 = UInt8(257)
-             performFunction(x: Int16(54))
-             performFunction(x: Int32(54))
-             performFunction(x: Int64(54))
-             let c = Character("s")
-             """,
-      expected: """
-                let v1 = 76 as UInt32
-                let v2 = 257 as UInt8
-                performFunction(x: 54 as Int16)
-                performFunction(x: 54 as Int32)
-                performFunction(x: 54 as Int64)
-                let c = "s" as Character
-                """)
+    let input =
+      """
+      let v1 = UInt32(76)
+      let v2 = UInt8(257)
+      performFunction(x: Int16(54))
+      performFunction(x: Int32(54))
+      performFunction(x: Int64(54))
+      let c = Character("s")
+      if 3 > Int(2) || someCondition {}
+      let a = Int(bitPattern: 123456)
+      """
+
+    performLint(AvoidInitializersForLiterals.self, input: input)
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("UInt32(76)"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("UInt8(257)"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("Int16(54)"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("Int32(54)"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("Int64(54)"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("Character(\"s\")"))
+    XCTAssertDiagnosed(.avoidInitializerStyleCast("Int(2) "))
+    XCTAssertNotDiagnosed(.avoidInitializerStyleCast("Int(bitPattern: 123456)"))
   }
 
   #if !os(macOS)