Add destination C module targets so you can prepare them directly. (swiftlang#7627)

This allows the C module to be targeted directly with the --target
argument. It is a no-op however, since the output of C modules are not
required for indexing.

(cherry picked from commit 09efb06)

Author: dschaefer2

Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift

@@ -110,4 +110,15 @@ extension LLBuildManifestBuilder {
             self.addNode(output, toTarget: .test)
         }
     }
+
+    /// Create a llbuild target for a Clang target preparation
+    func createClangPrepareCommand(
+        _ target: ClangTargetBuildDescription
+    ) throws {
+        // Create the node for the target so you can --target it.
+        // It is a no-op for index preparation.
+        let targetName = target.llbuildTargetName
+        let output: Node = .virtual(targetName)
+        self.manifest.addNode(output, toTarget: targetName)
+    }
 }

Sources/Build/BuildManifest/LLBuildManifestBuilder.swift

@@ -141,9 +141,12 @@ public class LLBuildManifestBuilder {
             case .swift(let desc):
                 try self.createSwiftCompileCommand(desc)
             case .clang(let desc):
-                // Need the clang targets for tools
                 if desc.target.buildTriple == .tools {
+                    // Need the clang targets for tools
                     try self.createClangCompileCommand(desc)
+                } else {
+                    // Hook up the clang module target
+                    try self.createClangPrepareCommand(desc)
                 }
             }
         }

Tests/BuildTests/PrepareForIndexTests.swift

@@ -63,4 +63,23 @@ class PrepareForIndexTests: XCTestCase {
             "outputs:\n\t\(outputs.filter { $0.hasSuffix(".o") }.joined(separator: "\n\t"))"
         )
     }
+
+    func testCModuleTarget() throws {
+        let (graph, fs, scope) = try trivialPackageGraph()
+
+        let plan = try BuildPlan(
+            destinationBuildParameters: mockBuildParameters(destination: .target, prepareForIndexing: true),
+            toolsBuildParameters: mockBuildParameters(destination: .host, prepareForIndexing: false),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: scope
+        )
+        let builder = LLBuildManifestBuilder(plan, fileSystem: fs, observabilityScope: scope)
+        let manifest = try builder.generatePrepareManifest(at: "/manifest")
+
+        // Ensure our C module is here.
+        let lib = try XCTUnwrap(graph.target(for: "lib", destination: .destination))
+        let name = lib.getLLBuildTargetName(buildParameters: plan.destinationBuildParameters)
+        XCTAssertTrue(manifest.targets.keys.contains(name))
+    }
 }