[Lint] Add a rule to detect and transform [<Type>]() into literal array init

Instead of using an archaic initializer call syntax, let's replace
it with an empty array literal with a type annotation (if there isn't one).

Author: xedin

Sources/SwiftFormat/Core/Pipelines+Generated.swift

@@ -141,6 +141,7 @@ class LintPipeline: SyntaxVisitor {
   }
 
   override func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
+    visitIfEnabled(AlwaysUseLiteralForEmptyArrayInit.visit, for: node)
     visitIfEnabled(NoEmptyTrailingClosureParentheses.visit, for: node)
     visitIfEnabled(OnlyOneTrailingClosureArgument.visit, for: node)
     visitIfEnabled(ReplaceForEachWithForLoop.visit, for: node)
@@ -356,6 +357,7 @@ extension FormatPipeline {
 
   func rewrite(_ node: Syntax) -> Syntax {
     var node = node
+    node = AlwaysUseLiteralForEmptyArrayInit(context: context).rewrite(node)
     node = DoNotUseSemicolons(context: context).rewrite(node)
     node = FileScopedDeclarationPrivacy(context: context).rewrite(node)
     node = FullyIndirectEnum(context: context).rewrite(node)

Sources/SwiftFormat/Core/RuleNameCache+Generated.swift

@@ -16,6 +16,7 @@
 @_spi(Testing)
 public let ruleNameCache: [ObjectIdentifier: String] = [
   ObjectIdentifier(AllPublicDeclarationsHaveDocumentation.self): "AllPublicDeclarationsHaveDocumentation",
+  ObjectIdentifier(AlwaysUseLiteralForEmptyArrayInit.self): "AlwaysUseLiteralForEmptyArrayInit",
   ObjectIdentifier(AlwaysUseLowerCamelCase.self): "AlwaysUseLowerCamelCase",
   ObjectIdentifier(AmbiguousTrailingClosureOverload.self): "AmbiguousTrailingClosureOverload",
   ObjectIdentifier(BeginDocumentationCommentWithOneLineSummary.self): "BeginDocumentationCommentWithOneLineSummary",

Sources/SwiftFormat/Core/RuleRegistry+Generated.swift

@@ -15,6 +15,7 @@
 enum RuleRegistry {
   static let rules: [String: Bool] = [
     "AllPublicDeclarationsHaveDocumentation": false,
+    "AlwaysUseLiteralForEmptyArrayInit": true,
     "AlwaysUseLowerCamelCase": true,
     "AmbiguousTrailingClosureOverload": true,
     "BeginDocumentationCommentWithOneLineSummary": false,

Sources/SwiftFormat/Rules/AlwaysUseLiteralForEmptyArrayInit.swift

@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+import SwiftSyntax
+import SwiftParser
+
+/// Never use `[<Type>]()` syntax. In call sites that should be replaced with `[]`,
+/// for initializations use explicit type combined with empty array literal `let _: [<Type>] = []`
+/// Static properties of a type that return that type should not include a reference to their type.
+///
+/// Lint:  Non-literal empty array initialization will yield a lint error.
+/// Format: All invalid use sites would be related with empty literal (with or without explicit type annotation).
+@_spi(Rules)
+public final class AlwaysUseLiteralForEmptyArrayInit : SyntaxFormatRule {
+  public override func visit(_ node: PatternBindingSyntax) -> PatternBindingSyntax {
+    guard let initializer = node.initializer else {
+      return node
+    }
+
+    // Check whether the initializer is `[<Type>]()`
+    guard let initCall = initializer.value.as(FunctionCallExprSyntax.self),
+          var arrayLiteral = initCall.calledExpression.as(ArrayExprSyntax.self),
+          initCall.arguments.isEmpty else {
+      return node
+    }
+
+    guard let elementType = getElementType(arrayLiteral) else {
+      return node
+    }
+
+    var replacement = node
+
+    var withFixIt = "[]"
+    if replacement.typeAnnotation == nil {
+      withFixIt = ": [\(elementType)] = []"
+    }
+
+    diagnose(.refactorEmptyArrayInit(replace: "\(initCall)", with: withFixIt), on: initCall)
+
+    if replacement.typeAnnotation == nil {
+      // Drop trailing trivia after pattern because ':' has to appear connected to it.
+      replacement.pattern = node.pattern.with(\.trailingTrivia, [])
+      // Add explicit type annotiation: ': [<Type>]`
+      replacement.typeAnnotation = .init(type: ArrayTypeSyntax(leadingTrivia: .space,
+                                                               element: elementType,
+                                                               trailingTrivia: .space))
+    }
+
+    // Replace initializer call with empty array literal: `[<Type>]()` -> `[]`
+    arrayLiteral.elements = ArrayElementListSyntax.init([])
+    replacement.initializer = initializer.with(\.value, ExprSyntax(arrayLiteral))
+
+    return replacement
+  }
+
+  private func getElementType(_ arrayLiteral: ArrayExprSyntax) -> TypeSyntax? {
+    guard let elementExpr = arrayLiteral.elements.firstAndOnly?.as(ArrayElementSyntax.self) else {
+      return nil
+    }
+
+    var parser = Parser(elementExpr.description)
+    let elementType = TypeSyntax.parse(from: &parser)
+    return elementType.hasError ? nil : elementType
+  }
+}
+
+extension Finding.Message {
+  public static func refactorEmptyArrayInit(replace: String, with: String) -> Finding.Message {
+    "replace '\(replace)' with '\(with)'"
+  }
+}

Tests/SwiftFormatTests/Rules/AlwaysUseLiteralForEmptyArrayInitTests.swift

@@ -0,0 +1,48 @@
+import _SwiftFormatTestSupport
+
+@_spi(Rules) import SwiftFormat
+
+final class AlwaysUseLiteralForEmptyArrayInitTests: LintOrFormatRuleTestCase {
+  func testPatternBindings() {
+    assertFormatting(
+      AlwaysUseLiteralForEmptyArrayInit.self,
+      input: """
+        public struct Test {
+          var value1 = 1️⃣[Int]()
+
+          func test(v: [Double] = [Double]()) {
+            let _ = 2️⃣[String]()
+          }
+        }
+
+        var _: [Category<Int>] = 3️⃣[Category<Int>]()
+        let _ = 4️⃣[(Int, Array<String>)]()
+        let _: [(String, Int, Float)] = 5️⃣[(String, Int, Float)]()
+
+        let _ = [(1, 2, String)]()
+        """,
+      expected: """
+        public struct Test {
+          var value1: [Int] = []
+
+          func test(v: [Double] = [Double]()) {
+            let _: [String] = []
+          }
+        }
+
+        var _: [Category<Int>] = []
+        let _: [(Int, Array<String>)] = []
+        let _: [(String, Int, Float)] = []
+
+        let _ = [(1, 2, String)]()
+        """,
+      findings: [
+        FindingSpec("1️⃣", message: "replace '[Int]()' with ': [Int] = []'"),
+        FindingSpec("2️⃣", message: "replace '[String]()' with ': [String] = []'"),
+        FindingSpec("3️⃣", message: "replace '[Category<Int>]()' with '[]'"),
+        FindingSpec("4️⃣", message: "replace '[(Int, Array<String>)]()' with ': [(Int, Array<String>)] = []'"),
+        FindingSpec("5️⃣", message: "replace '[(String, Int, Float)]()' with '[]'"),
+      ]
+    )
+  }
+}