Improve diagnostics when a product declared in a package is also used as a dependency (#3594)

* Resolves rdar://71912826 ([SR-13913]: Library product name must match target name??). 
* Checks if a target dependency includes a product declared in the same package, checks the targets of that product, and throws an error if invalid with improved diagnostics.

Author: elsh

Sources/PackageGraph/PackageGraph+Loading.swift

@@ -397,11 +397,19 @@ private func createResolvedPackages(
                     // found errors when there are more important errors to
                     // resolve (like authentication issues).
                     if !diagnostics.hasErrors {
+                        // Emit error if a product (not target) declared in the package is also a productRef (dependency)
+                        let declProductsAsDependency = package.products.filter { product in
+                            product.name == productRef.name
+                        }.map {$0.targets}.flatMap{$0}.filter { t in
+                            t.name != productRef.name
+                        }
+                        
                         let error = PackageGraphError.productDependencyNotFound(
                             package: package.identity.description,
                             targetName: targetBuilder.target.name,
                             dependencyProductName: productRef.name,
-                            dependencyPackageName: productRef.package
+                            dependencyPackageName: productRef.package,
+                            dependencyProductInDecl: !declProductsAsDependency.isEmpty
                         )
                         diagnostics.emit(error, location: package.diagnosticLocation)
                     }

Sources/PackageGraph/PackageGraph.swift

@@ -19,7 +19,7 @@ enum PackageGraphError: Swift.Error {
     case cycleDetected((path: [Manifest], cycle: [Manifest]))
 
     /// The product dependency not found.
-    case productDependencyNotFound(package: String, targetName: String, dependencyProductName: String, dependencyPackageName: String?)
+    case productDependencyNotFound(package: String, targetName: String, dependencyProductName: String, dependencyPackageName: String?, dependencyProductInDecl: Bool)
 
     /// The package dependency name does not match the package name.
     case incorrectPackageDependencyName(package: String, dependencyName: String, dependencyLocation: String, resolvedPackageManifestName: String, resolvedPackageURL: String)
@@ -192,9 +192,12 @@ extension PackageGraphError: CustomStringConvertible {
                 (cycle.path + cycle.cycle).map({ $0.name }).joined(separator: " -> ") +
                 " -> " + cycle.cycle[0].name
 
-        case .productDependencyNotFound(let package, let targetName, let dependencyProductName, let dependencyPackageName):
-            return "product '\(dependencyProductName)' required by package '\(package)' target '\(targetName)' \(dependencyPackageName.map{ "not found in package '\($0)'" } ?? "not found")."
-
+        case .productDependencyNotFound(let package, let targetName, let dependencyProductName, let dependencyPackageName, let dependencyProductInDecl):
+            if dependencyProductInDecl {
+                return "product '\(dependencyProductName)' is declared in the same package '\(package)' and can't be used as a dependency for target '\(targetName)'."
+            } else {
+                return "product '\(dependencyProductName)' required by package '\(package)' target '\(targetName)' \(dependencyPackageName.map{ "not found in package '\($0)'" } ?? "not found")."
+            }
         case .incorrectPackageDependencyName(let package, let dependencyName, let dependencyURL, let resolvedPackageManifestName, let resolvedPackageURL):
             return """
                 '\(package)' dependency on '\(dependencyURL)' has an explicit name '\(dependencyName)' which does not match the \

Tests/PackageGraphTests/PackageGraphTests.swift

@@ -573,6 +573,84 @@ class PackageGraphTests: XCTestCase {
         }
     }
 
+    func testProductDependencyDeclaredInSamePackage() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Foo/Sources/FooTarget/src.swift",
+            "/Foo/Tests/FooTests/source.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        _ = try loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Foo",
+                    path: "/Foo",
+                    packageKind: .root,
+                    packageLocation: "/Foo",
+                    products: [
+                        ProductDescription(name: "Foo", type: .library(.automatic), targets: ["FooTarget"]),
+                    ],
+                    targets: [
+                        TargetDescription(name: "FooTarget", dependencies: []),
+                        TargetDescription(name: "FooTests", dependencies: ["Foo"], type: .test),
+                    ]),
+            ]
+        )
+
+        DiagnosticsEngineTester(diagnostics) { result in
+            result.check(diagnostic: "product 'Foo' is declared in the same package 'foo' and can't be used as a dependency for target 'FooTests'.", behavior: .error, location: "'Foo' /Foo")
+        }
+    }
+    
+    func testExecutableTargetDependency() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+                "/XYZ/Sources/XYZ/main.swift",
+                "/XYZ/Tests/XYZTests/tests.swift"
+        )
+        let diagnostics = DiagnosticsEngine()
+        _ = try loadPackageGraph(fs: fs,
+                                 diagnostics: diagnostics,
+                                 manifests: [
+                    Manifest.createV4Manifest(
+                        name: "XYZ",
+                        path: "/XYZ",
+                        packageKind: .root,
+                        packageLocation: "/XYZ",
+                        targets: [
+                            TargetDescription(name: "XYZ", dependencies: [], type: .executable),
+                            TargetDescription(name: "XYZTests", dependencies: ["XYZ"], type: .test),
+                        ]),
+                    ]
+        )
+        DiagnosticsEngineTester(diagnostics) { _ in }
+    }
+    
+    func testSameProductAndTargetNames() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Foo/Sources/Foo/src.swift",
+            "/Foo/Tests/FooTests/source.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        _ = try loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Foo",
+                    path: "/Foo",
+                    packageKind: .root,
+                    packageLocation: "/Foo",
+                    products: [
+                        ProductDescription(name: "Foo", type: .library(.automatic), targets: ["Foo"]),
+                    ],
+                    targets: [
+                        TargetDescription(name: "Foo", dependencies: []),
+                        TargetDescription(name: "FooTests", dependencies: ["Foo"], type: .test),
+                    ]),
+            ]
+        )
+        DiagnosticsEngineTester(diagnostics) { _ in }
+    }
+
     func testProductDependencyNotFoundWithName() throws {
         let fs = InMemoryFileSystem(emptyFiles:
             "/Foo/Sources/FooTarget/foo.swift"