Add test for #805 (#1020)

Author: ileitch

Tests/Fixtures/Package.swift

@@ -17,6 +17,33 @@ var targets: [PackageDescription.Target] = [
     .target(
         name: "CrossModuleRetentionSupportFixtures"
     ),
+    .target(
+        name: "UnusedImportFixtureA",
+        path: "Sources/UnusedImportFixtures/A"
+    ),
+    .target(
+        name: "UnusedImportFixtureB",
+        dependencies: [
+            .target(name: "UnusedImportFixtureA")
+        ],
+        path: "Sources/UnusedImportFixtures/B"
+    ),
+    .target(
+        name: "UnusedImportFixtureC",
+        dependencies: [
+            .target(name: "UnusedImportFixtureA")
+        ],
+        path: "Sources/UnusedImportFixtures/C"
+    ),
+    .target(
+        name: "UnusedImportFixtureD",
+        dependencies: [
+            .target(name: "UnusedImportFixtureA"),
+            .target(name: "UnusedImportFixtureB"),
+            .target(name: "UnusedImportFixtureC")
+        ],
+        path: "Sources/UnusedImportFixtures/D"
+    ),
     .target(
         name: "RetentionFixtures",
         dependencies: [

Tests/Fixtures/Sources/UnusedImportFixtures/A/ConformanceBase.swift

@@ -0,0 +1,10 @@
+// Module A: Defines the base class and protocol
+
+public protocol ConformanceProtocol {
+    var conformanceProperty: Int { get }
+}
+
+public class ConformanceClass {
+    public init() {}
+}
+

Tests/Fixtures/Sources/UnusedImportFixtures/B/ConformanceProvider.swift

@@ -0,0 +1,9 @@
+// Module B: Provides conformance for ConformanceClass to ConformanceProtocol
+// This module's import should NOT be flagged as unused when the conformance is used
+
+import UnusedImportFixtureA
+
+extension ConformanceClass: ConformanceProtocol {
+    public var conformanceProperty: Int { 42 }
+}
+

Tests/Fixtures/Sources/UnusedImportFixtures/C/ConformanceFunction.swift

@@ -0,0 +1,9 @@
+// Module C: Provides the function that accepts ConformanceProtocol
+
+import UnusedImportFixtureA
+
+/// A function that accepts a ConformanceProtocol conforming type
+public func acceptConformingType(_ value: ConformanceProtocol) -> Int {
+    value.conformanceProperty
+}
+

Tests/Fixtures/Sources/UnusedImportFixtures/D/testUnusedImportFalsePositiveForConformanceProvider.swift

@@ -0,0 +1,27 @@
+// Module D: Unused import false-positive for module that provides a conformance
+//
+// This file imports:
+// - UnusedImportFixtureA: provides ConformanceClass and ConformanceProtocol
+// - UnusedImportFixtureB: provides ConformanceClass: ConformanceProtocol conformance
+// - UnusedImportFixtureC: provides acceptConformingType(_:)
+//
+// Module B's import is required because it provides the conformance, but no declarations from it
+// are directly referenced. Without this import, the call would fail to compile.
+//
+// The import should NOT be flagged as unused.
+
+import UnusedImportFixtureA  // Module A: type definitions
+import UnusedImportFixtureB  // Module B: conformance (no direct references!)
+import UnusedImportFixtureC  // Module C: function accepting protocol
+
+// periphery:ignore
+public class UnusedImportConformanceTestRetainer {
+    public func use() {
+        // This call requires ConformanceClass to conform to ConformanceProtocol.
+        // - ConformanceClass comes from Module A
+        // - acceptConformingType comes from Module C
+        // - The conformance is provided by Module B (no symbols directly referenced from B!)
+        _ = acceptConformingType(ConformanceClass())
+    }
+}
+

Tests/PeripheryTests/UnusedImportTest.swift

@@ -0,0 +1,36 @@
+import Configuration
+import SystemPackage
+@testable import TestShared
+
+/// Tests for unused import detection.
+final class UnusedImportTest: SPMSourceGraphTestCase {
+    override static func setUp() {
+        super.setUp()
+
+        build(projectPath: FixturesProjectPath)
+        index(configuration: Configuration())
+    }
+
+    func testUnusedImportFalsePositiveForConformanceProvider() {
+        // Module D imports A, B, C where:
+        // - A provides ConformanceClass and ConformanceProtocol
+        // - B provides the conformance (no direct references!)
+        // - C provides acceptConformingType function
+        //
+        // Module B's import should NOT be flagged as unused since it provides the conformance.
+        module("UnusedImportFixtureD") {
+            self.assertReferenced(.module("UnusedImportFixtureA"))
+            self.assertReferenced(.module("UnusedImportFixtureB"))
+            self.assertReferenced(.module("UnusedImportFixtureC"))
+        }
+
+        module("UnusedImportFixtureA") {
+            self.assertReferenced(.class("ConformanceClass"))
+            self.assertReferenced(.protocol("ConformanceProtocol"))
+        }
+
+        module("UnusedImportFixtureC") {
+            self.assertReferenced(.functionFree("acceptConformingType(_:)"))
+        }
+    }
+}