better diagnostics when potentially duplicate packages are found

motivation: with the intriduction of the regsitry, there is a higher likelyhood of running into duplicate packages

changes: perform a heuristics to try and determin if the packages are duplicate and provide a better diagnostics instead of the standard "duplicate product" one

Author: tomerd

Sources/PackageGraph/PackageGraph+Loading.swift

@@ -505,7 +505,7 @@ private func createResolvedPackages(
                         throw InternalError("dependency reference for \(product.packageBuilder.package.manifest.packageLocation) not found")
                     }
                     let referencedPackageName = referencedPackageDependency.nameForTargetDependencyResolutionOnly
-                    if productRef.name !=  referencedPackageName {
+                    if productRef.name != referencedPackageName {
                         let error = PackageGraphError.productDependencyMissingPackage(
                             productName: productRef.name,
                             targetName: targetBuilder.target.name,
@@ -522,16 +522,80 @@ private func createResolvedPackages(
 
     // If a target with similar name was encountered before, we emit a diagnostic.
     if foundDuplicateTarget {
+        var duplicateTargets = [String: [Package]]()
         for targetName in allTargetNames.sorted() {
-            // Find the packages this target is present in.
             let packages = packageBuilders
                 .filter({ $0.targets.contains(where: { $0.target.name == targetName }) })
-                .map{ $0.package.identity.description }
-                .sorted()
+                .map{ $0.package }
             if packages.count > 1 {
-                observabilityScope.emit(ModuleError.duplicateModule(targetName, packages))
+                duplicateTargets[targetName, default: []].append(contentsOf: packages)
             }
         }
+
+        struct Pair: Hashable {
+            let package1: Package
+            let package2: Package
+
+            static func == (lhs: Pair, rhs: Pair) -> Bool {
+                return lhs.package1.identity == rhs.package1.identity &&
+                    lhs.package2.identity == rhs.package2.identity
+            }
+
+            public func hash(into hasher: inout Hasher) {
+                hasher.combine(self.package1.identity)
+                hasher.combine(self.package2.identity)
+            }
+        }
+
+        var potentiallyDuplicatePackages = [Pair: [String]]()
+        for entry in duplicateTargets {
+            // the duplicate is across exactly two packages
+            if entry.value.count == 2 {
+                potentiallyDuplicatePackages[Pair(package1: entry.value[0], package2: entry.value[1]), default: []].append(entry.key)
+            }
+        }
+
+        var duplicateTargetsAddressed = [String]()
+        for potentiallyDuplicatePackage in potentiallyDuplicatePackages {
+            // more than three target matches, or all targets in the package match
+            if potentiallyDuplicatePackage.value.count > 3 || potentiallyDuplicatePackage.value.sorted() == potentiallyDuplicatePackage.key.package1.targets.map({ $0.name }).sorted() {
+                switch (potentiallyDuplicatePackage.key.package1.identity.registry, potentiallyDuplicatePackage.key.package2.identity.registry) {
+                case (.some(let registryIdentity), .none):
+                    observabilityScope.emit(
+                        ModuleError.duplicateModulesScmAndRegistry(
+                            regsitryPackage: registryIdentity,
+                            scmPackage: potentiallyDuplicatePackage.key.package2.identity,
+                            targets: potentiallyDuplicatePackage.value
+                        )
+                    )
+                case (.none, .some(let registryIdentity)):
+                    observabilityScope.emit(
+                        ModuleError.duplicateModulesScmAndRegistry(
+                            regsitryPackage: registryIdentity,
+                            scmPackage: potentiallyDuplicatePackage.key.package1.identity,
+                            targets: potentiallyDuplicatePackage.value
+                        )
+                    )
+                default:
+                    observabilityScope.emit(
+                        ModuleError.duplicateModules(
+                            package: potentiallyDuplicatePackage.key.package1.identity,
+                            otherPackage: potentiallyDuplicatePackage.key.package2.identity,
+                            targets: potentiallyDuplicatePackage.value
+                        )
+                    )
+                }
+                duplicateTargetsAddressed += potentiallyDuplicatePackage.value
+            }
+        }
+
+        for entry in duplicateTargets.filter({ !duplicateTargetsAddressed.contains($0.key) }) {
+            observabilityScope.emit(
+                ModuleError.duplicateModule(
+                    targetName: entry.key,
+                    packages: entry.value.map{ $0.identity })
+            )
+        }
     }
 
     return try packageBuilders.map{ try $0.construct() }

Sources/PackageLoading/PackageBuilder.swift

@@ -27,7 +27,7 @@ public enum ModuleError: Swift.Error {
     }
 
     /// Indicates two targets with the same name and their corresponding packages.
-    case duplicateModule(String, [String])
+    case duplicateModule(targetName: String, packages: [PackageIdentity])
 
     /// The referenced target could not be found.
     case moduleNotFound(String, TargetDescription.TargetType, shouldSuggestRelaxedSourceDir: Bool)
@@ -79,14 +79,20 @@ public enum ModuleError: Swift.Error {
 
     /// A C target has declared an embedded resource
     case embedInCodeNotSupported(target: String)
+
+    /// Indicates several targets with the same name exist in packages
+    case duplicateModules(package: PackageIdentity, otherPackage: PackageIdentity, targets: [String])
+
+    /// Indicates several targets with the same name exist in a registry and scm package
+    case duplicateModulesScmAndRegistry(regsitryPackage: PackageIdentity.RegistryIdentity, scmPackage: PackageIdentity, targets: [String])
 }
 
 extension ModuleError: CustomStringConvertible {
     public var description: String {
         switch self {
-        case .duplicateModule(let name, let packages):
-            let packages = packages.joined(separator: "', '")
-            return "multiple targets named '\(name)' in: '\(packages)'; consider using the `moduleAliases` parameter in manifest to provide unique names"
+        case .duplicateModule(let target, let packages):
+            let packages = packages.map{ $0.description }.sorted().joined(separator: "', '")
+            return "multiple targets named '\(target)' in: '\(packages)'; consider using the `moduleAliases` parameter in manifest to provide unique names"
         case .moduleNotFound(let target, let type, let shouldSuggestRelaxedSourceDir):
             let folderName = (type == .test) ? "Tests" : (type == .plugin) ? "Plugins" : "Sources"
             var clauses = ["Source files for target \(target) should be located under '\(folderName)/\(target)'"]
@@ -134,6 +140,12 @@ extension ModuleError: CustomStringConvertible {
             return "plugin target '\(target)' doesn't have a 'capability' property"
         case .embedInCodeNotSupported(let target):
             return "embedding resources in code not supported for C-family language target \(target)"
+        case .duplicateModules(let package, let otherPackage, let targets):
+            let targets = targets.sorted().joined(separator: "', '")
+            return "multiple identical targets '\(targets)' appear in package '\(package)' and '\(otherPackage)', this may indicate that the two packages are the same and can be de-duplicated by using mirrors. if they are not duplicate consider using the `moduleAliases` parameter in manifest to provide unique names"
+        case .duplicateModulesScmAndRegistry(let regsitryPackage, let scmPackage, let targets):
+            let targets = targets.sorted().joined(separator: "', '")
+            return "multiple identical targets '\(targets)' appear in registry package '\(regsitryPackage)' and source control package '\(scmPackage)', this may indicate that the two packages are the same and can be de-duplicated by activating the automatic source-control to registry replacement, or by using mirrors. if they are not duplicate consider using the `moduleAliases` parameter in manifest to provide unique names"
         }
     }
 }