[PackageGraph] Diagnose duplicate products across package graph

<rdar://problem/42036789> [SR-8220]: duplicate command in 'commands' map

Author: aciidgh

Sources/Basic/CollectionAlgorithms.swift

@@ -60,3 +60,13 @@ extension Collection where Element: Hashable {
         return table.values.filter({ $0.count > 1 })
     }
 }
+
+extension Sequence {
+    public func findDuplicateElements<Key: Hashable>(
+        by keyPath: KeyPath<Self.Element, Key>
+    ) -> [[Element]] {
+        return Dictionary(grouping: self, by: { $0[keyPath: keyPath] })
+            .values
+            .filter({ $0.count > 1 })
+    }
+}

Sources/PackageGraph/PackageGraphLoader.swift

@@ -37,6 +37,9 @@ enum PackageGraphError: Swift.Error {
 
     /// The product dependency was found but the package name did not match.
     case productDependencyIncorrectPackage(name: String, package: String)
+
+    /// A product was found in multiple packages.
+    case duplicateProduct(product: String, packages: [String])
 }
 
 extension PackageGraphError: CustomStringConvertible {
@@ -55,6 +58,9 @@ extension PackageGraphError: CustomStringConvertible {
 
         case .productDependencyIncorrectPackage(let name, let package):
             return "product dependency '\(name)' in package '\(package)' not found"
+
+        case .duplicateProduct(let product, let packages):
+            return "multiple products named '\(product)' in: \(packages.joined(separator: ", "))"
         }
     }
 }
@@ -242,6 +248,28 @@ private func createResolvedPackages(
         })
     }
 
+    // Find duplicate products in the package graph.
+    let duplicateProducts = packageBuilders
+        .flatMap({ $0.products })
+        .map({ $0.product })
+        .findDuplicateElements(by: \.name)
+        .map({ $0[0].name })
+
+    // Emit diagnostics for duplicate products.
+    for productName in duplicateProducts {
+        let packages = packageBuilders
+            .filter({ $0.products.contains(where: { $0.product.name == productName }) })
+            .map({ $0.package.name })
+            .sorted()
+
+        diagnostics.emit(PackageGraphError.duplicateProduct(product: productName, packages: packages))
+    }
+
+    // Remove the duplicate products from the builders.
+    for packageBuilder in packageBuilders {
+        packageBuilder.products = packageBuilder.products.filter({ !duplicateProducts.contains($0.product.name) })
+    }
+
     // The set of all target names.
     var allTargetNames = Set<String>()
 

Tests/PackageGraphTests/PackageGraphTests.swift

@@ -588,10 +588,6 @@ class PackageGraphTests: XCTestCase {
                     dependencies: [
                         PackageDependencyDescription(url: "/Dep1", requirement: .upToNextMajor(from: "1.0.0")),
                     ],
-                    products: [
-                        ProductDescription(name: "FooLibrary", targets: ["Foo"]),
-                        ProductDescription(name: "BarLibrary", targets: ["Bar"]),
-                    ],
                     targets: [
                         TargetDescription(name: "Foo", dependencies: ["BazLibrary"]),
                         TargetDescription(name: "Bar"),
@@ -628,4 +624,51 @@ class PackageGraphTests: XCTestCase {
             result.check(diagnostic: "multiple targets named 'Foo' in: Dep2, Start", behavior: .error)
         }
     }
+
+    func testDuplicateProducts() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Foo/Sources/Foo/foo.swift",
+            "/Bar/Sources/Bar/bar.swift",
+            "/Baz/Sources/Baz/baz.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        _ = loadPackageGraph(root: "/Foo", fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Foo",
+                    path: "/Foo",
+                    url: "/Foo",
+                    dependencies: [
+                        PackageDependencyDescription(url: "/Bar", requirement: .upToNextMajor(from: "1.0.0")),
+                        PackageDependencyDescription(url: "/Baz", requirement: .upToNextMajor(from: "1.0.0")),
+                    ],
+                    targets: [
+                        TargetDescription(name: "Foo", dependencies: ["Bar"]),
+                    ]),
+                Manifest.createV4Manifest(
+                    name: "Bar",
+                    path: "/Bar",
+                    url: "/Bar",
+                    products: [
+                        ProductDescription(name: "Bar", targets: ["Bar"])
+                    ],
+                    targets: [
+                        TargetDescription(name: "Bar"),
+                    ]),
+                Manifest.createV4Manifest(
+                    name: "Baz",
+                    path: "/Baz",
+                    url: "/Baz",
+                    products: [
+                        ProductDescription(name: "Bar", targets: ["Baz"])
+                    ],
+                    targets: [
+                        TargetDescription(name: "Baz"),
+                    ]),
+            ]
+        )
+
+        XCTAssertTrue(diagnostics.diagnostics.contains(where: { $0.localizedDescription.contains("multiple products named 'Bar' in: Bar, Baz") }), "\(diagnostics.diagnostics)")
+    }
 }

Tests/PackageGraphTests/XCTestManifests.swift

@@ -26,6 +26,7 @@ extension PackageGraphTests {
         ("testCycle", testCycle),
         ("testDuplicateInterPackageTargetNames", testDuplicateInterPackageTargetNames),
         ("testDuplicateModules", testDuplicateModules),
+        ("testDuplicateProducts", testDuplicateProducts),
         ("testEmptyDependency", testEmptyDependency),
         ("testMultipleDuplicateModules", testMultipleDuplicateModules),
         ("testNestedDuplicateModules", testNestedDuplicateModules),