Implement AmbiguousTrailingClosureOverload rule. (swiftlang#82)

Author: allevato

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

@@ -9,5 +9,63 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#trailing-closures
 public final class AmbiguousTrailingClosureOverload: SyntaxLintRule {
+  func diagnoseBadOverloads(_ overloads: [String: [FunctionDeclSyntax]]) {
+    for (_, decls) in overloads where decls.count > 1 {
+      let decl = decls[0]
+      diagnose(.ambiguousTrailingClosureOverload(decl.fullDeclName), on: decl.identifier) {
+        for decl in decls.dropFirst() {
+          $0.note(
+            .otherAmbiguousOverloadHere(decl.fullDeclName),
+            location: decl.identifier.startLocation(in: self.context.fileURL)
+          )
+        }
+      }
+    }
+  }
 
+  func discoverAndDiagnoseOverloads(_ functions: [FunctionDeclSyntax]) {
+    var overloads = [String: [FunctionDeclSyntax]]()
+    var staticOverloads = [String: [FunctionDeclSyntax]]()
+    for fn in functions {
+      let params = fn.signature.input.parameterList
+      guard params.count == 1 else { continue }
+      let firstParam = params[0]
+      guard firstParam.type is FunctionTypeSyntax else { continue }
+      if let mods = fn.modifiers, mods.has(modifier: "static") || mods.has(modifier: "class") {
+        staticOverloads[fn.identifier.text, default: []].append(fn)
+      } else {
+        overloads[fn.identifier.text, default: []].append(fn)
+      }
+    }
+
+    diagnoseBadOverloads(overloads)
+    diagnoseBadOverloads(staticOverloads)
+  }
+
+  public override func visit(_ node: SourceFileSyntax) {
+    let functions = node.statements.compactMap { $0.item as? FunctionDeclSyntax }
+    discoverAndDiagnoseOverloads(functions)
+    super.visit(node)
+  }
+
+  public override func visit(_ node: CodeBlockSyntax) {
+    let functions = node.statements.compactMap { $0.item as? FunctionDeclSyntax }
+    discoverAndDiagnoseOverloads(functions)
+    super.visit(node)
+  }
+
+  public override func visit(_ decls: MemberDeclBlockSyntax) {
+    let functions = decls.members.compactMap { $0.decl as? FunctionDeclSyntax }
+    discoverAndDiagnoseOverloads(functions)
+    super.visit(decls)
+  }
+}
+
+extension Diagnostic.Message {
+  static func ambiguousTrailingClosureOverload(_ decl: String) -> Diagnostic.Message {
+    return .init(.warning, "rename '\(decl)' so it is no longer ambiguous with a trailing closure")
+  }
+  static func otherAmbiguousOverloadHere(_ decl: String) -> Diagnostic.Message {
+    return .init(.note, "ambiguous overload '\(decl)' is here")
+  }
 }

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

@@ -0,0 +1,57 @@
+import Foundation
+import SwiftSyntax
+import XCTest
+
+@testable import Rules
+
+public class AmbiguousTrailingClosureOverloadTests: DiagnosingTestCase {
+  public func testAmbiguousOverloads() {
+    performLint(
+      AmbiguousTrailingClosureOverload.self,
+      input: """
+             func strong(mad: () -> Int) {}
+             func strong(bad: (Bool) -> Bool) {}
+             func strong(sad: (String) -> Bool) {}
+
+             class A {
+               static func the(cheat: (Int) -> Void) {}
+               class func the(sneak: (Int) -> Void) {}
+               func the(kingOfTown: () -> Void) {}
+               func the(cheatCommandos: (Bool) -> Void) {}
+               func the(brothersStrong: (String) -> Void) {}
+             }
+
+             struct B {
+               func hom(estar: () -> Int) {}
+               func hom(sar: () -> Bool) {}
+
+               static func baleeted(_ f: () -> Void) {}
+               func baleeted(_ f: () -> Void) {}
+             }
+             """
+    )
+
+    XCTAssertDiagnosed(.ambiguousTrailingClosureOverload("strong(mad:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("strong(bad:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("strong(sad:)"))
+
+    XCTAssertDiagnosed(.ambiguousTrailingClosureOverload("the(cheat:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("the(sneak:)"))
+
+    XCTAssertDiagnosed(.ambiguousTrailingClosureOverload("the(kingOfTown:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("the(cheatCommandos:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("the(brothersStrong:)"))
+
+    XCTAssertDiagnosed(.ambiguousTrailingClosureOverload("hom(estar:)"))
+    XCTAssertDiagnosed(.otherAmbiguousOverloadHere("hom(sar:)"))
+
+    XCTAssertNotDiagnosed(.ambiguousTrailingClosureOverload("baleeted(_:)"))
+    XCTAssertNotDiagnosed(.otherAmbiguousOverloadHere("baleeted(_:)"))
+  }
+
+#if !os(macOS)
+  static let allTests = [
+    AmbiguousTrailingClosureOverloadTests.testAmbiguousOverloads,
+  ]
+#endif
+}

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

@@ -16,6 +16,9 @@ public class DiagnosingTestCase: XCTestCase {
     var registeredDiagnostics = [String]()
     func handle(_ diagnostic: Diagnostic) {
       registeredDiagnostics.append(diagnostic.message.text)
+      for note in diagnostic.notes {
+        registeredDiagnostics.append(note.message.text)
+      }
     }
     func finalize() {}
   }