Verify that only targets that are manifest dependencies can be imported.

This change introduces a build plan verification step that attempts to detect scenarios where a target contains an `import` of another target in the package without declaring the imported target as a dependency in the manifest.
This is done via SwiftDriver's import-prescan capability which relies on libSwiftScan to quickly parse a target's sources and identify all `import`ed modules.

Author: artemcm

Sources/Build/ManifestBuilder.swift

@@ -208,7 +208,7 @@ extension LLBuildManifestBuilder {
         } else if buildParameters.emitSwiftModuleSeparately {
             try self.addSwiftCmdsEmitSwiftModuleSeparately(target, inputs: inputs, objectNodes: objectNodes, moduleNode: moduleNode)
         } else {
-            self.addCmdWithBuiltinSwiftTool(target, inputs: inputs, cmdOutputs: cmdOutputs)
+            try self.addCmdWithBuiltinSwiftTool(target, inputs: inputs, cmdOutputs: cmdOutputs)
         }
 
         self.addTargetCmd(target, cmdOutputs: cmdOutputs)
@@ -474,14 +474,63 @@ extension LLBuildManifestBuilder {
         )
     }
 
+    // Emit an error if this target imports another target in this build
+    // without specifying it as a dependency
+    private func verifyTargetImports(_ target: SwiftTargetBuildDescription) throws {
+        // ArtemC: prototype for target import verification
+        var verificationFailure = false
+        do {
+
+            var commandLine = try target.emitCommandLine();
+            commandLine.append("-driver-use-frontend-path")
+            commandLine.append(buildParameters.toolchain.swiftCompiler.pathString)
+            let resolver = try ArgsResolver(fileSystem: target.fs)
+            let executor = SPMSwiftDriverExecutor(resolver: resolver,
+                                                  fileSystem: target.fs,
+                                                  env: ProcessEnv.vars)
+            var driver = try Driver(args: commandLine,
+                                    diagnosticsEngine: plan.diagnostics,
+                                    fileSystem: target.fs,
+                                    executor: executor)
+            let imports = try driver.performImportPrescan().imports
+            let dependencyNames = Set(try target.target.recursiveTargetDependencies().map { $0.c99name })
+            let nonDependencyTargetNames =
+                Set(plan.targetMap.map { $0.value.target.c99name }
+                                  .filter { !dependencyNames.contains($0) })
+
+            print("--------------------------------------------------------")
+            print("Perform target import verification for: \(target.target.c99name)")
+            print("Imports: \(imports)")
+            print("Dependencies: \(dependencyNames)")
+            print("Other targets: \(nonDependencyTargetNames)")
+            print("--------------------------------------------------------")
+
+            let importedTargetsMissingDependency = Set(imports).intersection(nonDependencyTargetNames)
+            if !importedTargetsMissingDependency.isEmpty {
+                verificationFailure = true
+                plan.diagnostics.emit(error: "Target \(target.target.name) imports another target (\(importedTargetsMissingDependency.first!)) in the package without declaring it a dependency.", location: nil)
+            }
+        } catch {
+            print("Unable to verify target imports due to: \(error)")
+            return
+        }
+        if verificationFailure {
+            throw StringError("Build manifest creation failed.")
+        }
+    }
+
     private func addCmdWithBuiltinSwiftTool(
         _ target: SwiftTargetBuildDescription,
         inputs: [Node],
         cmdOutputs: [Node]
-    ) {
+    ) throws {
         let isLibrary = target.target.type == .library || target.target.type == .test
         let cmdName = target.target.getCommandName(config: buildConfig)
 
+        // Emit an error if this target imports another target in this build
+        // without specifying it as a dependency
+        try verifyTargetImports(target)
+
         manifest.addSwiftCmd(
             name: cmdName,
             inputs: inputs,

Tests/BuildTests/BuildPlanTests.swift

@@ -167,6 +167,84 @@ final class BuildPlanTests: XCTestCase {
       #endif
     }
 
+    func testTargetImportDependenciesOnlyVerification() throws {
+        try withTemporaryDirectory { path in
+            // Create a test package with three targets:
+            // A and B
+            let fs = localFileSystem
+            try fs.changeCurrentWorkingDirectory(to: path)
+            let testDirPath = path.appending(component: "VerificationTest")
+            let buildDirPath = path.appending(component: ".build")
+            let sourcesPath = testDirPath.appending(component: "Sources")
+            let aPath = sourcesPath.appending(component: "A")
+            let bPath = sourcesPath.appending(component: "B")
+            try fs.createDirectory(testDirPath)
+            try fs.createDirectory(buildDirPath)
+            try fs.createDirectory(sourcesPath)
+            try fs.createDirectory(aPath)
+            try fs.createDirectory(bPath)
+            let main = aPath.appending(component: "main.swift")
+            let aSwift = aPath.appending(component: "A.swift")
+            let bSwift = bPath.appending(component: "B.swift")
+            try localFileSystem.writeFileContents(main) {
+              $0 <<< "baz();"
+            }
+            try localFileSystem.writeFileContents(aSwift) {
+                $0 <<< "public func foo() { }"
+            }
+            try localFileSystem.writeFileContents(bSwift) {
+                // This target depends on, and imports 'A', but forgets to
+                // specify it as dependency in the manifest.
+                $0 <<< "import A;"
+                $0 <<< "public func bar() { foo() }"
+            }
+
+            // Plan package build
+            let diagnostics = DiagnosticsEngine()
+            let graph = try loadPackageGraph(fs: fs, diagnostics: diagnostics,
+                manifests: [
+                    Manifest.createV4Manifest(
+                        name: "VerificationTest",
+                        path: testDirPath.description,
+                        packageKind: .root,
+                        packageLocation: "/VerificationTest",
+                        targets: [
+                            TargetDescription(name: "A", dependencies: []),
+                            TargetDescription(name: "B", dependencies: [])
+                        ]),
+                ]
+            )
+            XCTAssertNoDiagnostics(diagnostics)
+            do {
+                let plan = try BuildPlan(
+                    buildParameters: mockBuildParameters(
+                        buildPath: buildDirPath,
+                        config: .release,
+                        toolchain: Resources.default.toolchain,
+                        destinationTriple: Resources.default.toolchain.triple,
+                        useExplicitModuleBuild: false
+                    ),
+                    graph: graph,
+                    diagnostics: diagnostics,
+                    fileSystem: fs
+                )
+
+                let yaml = buildDirPath.appending(component: "release.yaml")
+                let llbuild = LLBuildManifestBuilder(plan)
+                XCTAssertThrows(StringError("Build manifest creation failed."), { try llbuild.generateManifest(at: yaml) })
+                XCTAssertEqual(diagnostics.diagnostics.count, 1)
+                let firstDiagnostic = diagnostics.diagnostics.first.map({ $0.message.text })
+                XCTAssertTrue(firstDiagnostic == "Target B imports another target (A) in the package without declaring it a dependency.")
+            } catch Driver.Error.unableToDecodeFrontendTargetInfo {
+                // If the toolchain being used is sufficiently old, the integrated driver
+                // will not be able to parse the `-print-target-info` output. In which case,
+                // we cannot yet rely on the integrated swift driver.
+                // This effectively guards the test from running on unupported, older toolchains.
+                throw XCTSkip()
+            }
+        }
+    }
+
     func testExplicitSwiftPackageBuild() throws {
         try withTemporaryDirectory { path in
             // Create a test package with three targets: