Fix incremental builds for embedInCode resources

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -77,10 +77,13 @@ public final class SwiftTargetBuildDescription {
         return resources.filter { $0.rule != .embedInCode }.isEmpty == false
     }
 
-    private var needsResourceEmbedding: Bool {
-        return resources.filter { $0.rule == .embedInCode }.isEmpty == false
+    var resourceFilesToEmbed: [AbsolutePath] {
+        return resources.filter { $0.rule == .embedInCode }.map { $0.path }
     }
 
+    /// The path to Swift source file embedding resource contents if needed.
+    private(set) var resourcesEmbeddingSource: AbsolutePath?
+
     /// The list of all source files in the target, including the derived ones.
     public var sources: [AbsolutePath] {
         self.target.sources.paths + self.derivedSources.paths + self.pluginDerivedSources.paths
@@ -317,7 +320,10 @@ public final class SwiftTargetBuildDescription {
             }
         }
 
-        try self.generateResourceEmbeddingCode()
+        if !resourceFilesToEmbed.isEmpty {
+            resourcesEmbeddingSource = try addResourceEmbeddingSource()
+        }
+
         try self.generateTestObservation()
     }
 
@@ -348,32 +354,10 @@ public final class SwiftTargetBuildDescription {
         try self.fileSystem.writeIfChanged(path: path, string: content)
     }
 
-    // FIXME: This will not work well for large files, as we will store the entire contents, plus its byte array
-    // representation in memory and also `writeIfChanged()` will read the entire generated file again.
-    private func generateResourceEmbeddingCode() throws {
-        guard needsResourceEmbedding else { return }
-
-        var content =
-            """
-            struct PackageResources {
-
-            """
-
-        try resources.forEach {
-            guard $0.rule == .embedInCode else { return }
-
-            let variableName = $0.path.basename.spm_mangledToC99ExtendedIdentifier()
-            let fileContent = try Data(contentsOf: URL(fileURLWithPath: $0.path.pathString)).map { String($0) }.joined(separator: ",")
-
-            content += "static let \(variableName): [UInt8] = [\(fileContent)]\n"
-        }
-
-        content += "}"
-
+    private func addResourceEmbeddingSource() throws -> AbsolutePath {
         let subpath = try RelativePath(validating: "embedded_resources.swift")
         self.derivedSources.relativePaths.append(subpath)
-        let path = self.derivedSources.root.appending(subpath)
-        try self.fileSystem.writeIfChanged(path: path, string: content)
+        return self.derivedSources.root.appending(subpath)
     }
 
     /// Generate the resource bundle accessor, if appropriate.

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -417,6 +417,11 @@ extension LLBuildManifestBuilder {
             inputs.append(resourcesNode)
         }
 
+        if let resourcesEmbeddingSource = target.resourcesEmbeddingSource {
+            let resourceFilesToEmbed = target.resourceFilesToEmbed
+            self.manifest.addWriteEmbeddedResourcesCommand(resources: resourceFilesToEmbed, outputPath: resourcesEmbeddingSource)
+        }
+
         func addStaticTargetInputs(_ target: ResolvedModule) throws {
             // Ignore C Modules.
             if target.underlying is SystemLibraryTarget { return }

Sources/LLBuildManifest/LLBuildManifest.swift

@@ -27,7 +27,8 @@ public enum WriteAuxiliary {
         LinkFileList.self,
         SourcesFileList.self,
         SwiftGetVersion.self,
-        XCTestInfoPlist.self
+        XCTestInfoPlist.self,
+        EmbeddedResources.self,
     ]
 
     public struct EntitlementPlist: AuxiliaryFileType {
@@ -159,6 +160,35 @@ public enum WriteAuxiliary {
             case undefinedPrincipalClass
         }
     }
+
+    public struct EmbeddedResources: AuxiliaryFileType {
+        public static let name = "embedded-resources"
+
+        public static func computeInputs(resources: [AbsolutePath]) -> [Node] {
+            return [.virtual(Self.name)] + resources.map { Node.file($0) }
+        }
+
+        // FIXME: This will not work well for large files, as we will store the entire contents, plus its byte array
+        // representation in memory.
+        public static func getFileContents(inputs: [Node]) throws -> String {
+            var content =
+                """
+                struct PackageResources {
+
+                """
+
+            for input in inputs where input.kind == .file {
+                let resourcePath = try AbsolutePath(validating: input.name)
+                let variableName = resourcePath.basename.spm_mangledToC99ExtendedIdentifier()
+                let fileContent = try Data(contentsOf: URL(fileURLWithPath: resourcePath.pathString)).map { String($0) }.joined(separator: ",")
+
+                content += "static let \(variableName): [UInt8] = [\(fileContent)]\n"
+            }
+
+            content += "}"
+            return content
+        }
+    }
 }
 
 public struct LLBuildManifest {
@@ -280,6 +310,16 @@ public struct LLBuildManifest {
         commands[name] = Command(name: name, tool: tool)
     }
 
+    public mutating func addWriteEmbeddedResourcesCommand(
+        resources: [AbsolutePath],
+        outputPath: AbsolutePath
+    ) {
+        let inputs = WriteAuxiliary.EmbeddedResources.computeInputs(resources: resources)
+        let tool = WriteAuxiliaryFile(inputs: inputs, outputFilePath: outputPath)
+        let name = outputPath.pathString
+        commands[name] = Command(name: name, tool: tool)
+    }
+
     public mutating func addPkgStructureCmd(
         name: String,
         inputs: [Node],

Tests/FunctionalTests/ResourcesTests.swift

@@ -122,8 +122,23 @@ class ResourcesTests: XCTestCase {
 
     func testResourcesEmbeddedInCode() throws {
         try fixture(name: "Resources/EmbedInCodeSimple") { fixturePath in
-            let result = try executeSwiftRun(fixturePath, "EmbedInCodeSimple")
-            XCTAssertEqual(result.stdout, "hello world\n\n")
+            let execPath = fixturePath.appending(components: ".build", "debug", "EmbedInCodeSimple")
+            try executeSwiftBuild(fixturePath)
+            let result = try Process.checkNonZeroExit(args: execPath.pathString)
+            XCTAssertEqual(result, "hello world\n\n")
+            let resourcePath = fixturePath.appending(
+                components: "Sources", "EmbedInCodeSimple", "best.txt")
+
+            // Check incremental builds
+            for i in 0..<2 {
+              let content = "Hi there \(i)!"
+              // Update the resource file.
+              try localFileSystem.writeFileContents(resourcePath, string: content)
+              try executeSwiftBuild(fixturePath)
+              // Run the executable again.
+              let result2 = try Process.checkNonZeroExit(args: execPath.pathString)
+              XCTAssertEqual(result2, "\(content)\n")
+            }
         }
     }