[Build] Add code generation for the resources bundle accessor

<rdar://problem/56585517>

Author: aciidgh

Sources/Build/BuildDelegate.swift

@@ -11,6 +11,7 @@
 import TSCBasic
 import TSCUtility
 import SPMLLBuild
+import PackageModel
 import Dispatch
 import Foundation
 

Sources/Build/BuildPlan.swift

@@ -497,13 +497,20 @@ public final class SwiftTargetBuildDescription {
     let buildParameters: BuildParameters
 
     /// Path to the temporary directory for this target.
-    var tempsPath: AbsolutePath {
-        return buildParameters.buildPath.appending(component: target.c99name + ".build")
-    }
+    let tempsPath: AbsolutePath
+
+    /// The directory containing derived sources of this target.
+    ///
+    /// These are the source files generated during the build.
+    private var derivedSources: Sources
+
+    /// The list of all source files in the target, including the derived ones.
+    var sources: [AbsolutePath] { target.sources.paths + derivedSources.paths }
 
     /// The objects in this target.
     var objects: [AbsolutePath] {
-        return target.sources.relativePaths.map({ tempsPath.appending(RelativePath("\($0.pathString).o")) })
+        let relativePaths = target.sources.relativePaths + derivedSources.relativePaths
+        return relativePaths.map{ tempsPath.appending(RelativePath("\($0.pathString).o")) }
     }
 
     /// The path to the swiftmodule file after compilation.
@@ -558,10 +565,46 @@ public final class SwiftTargetBuildDescription {
         self.isTestTarget = isTestTarget ?? (target.type == .test)
         self.testDiscoveryTarget = testDiscoveryTarget
         self.fs = fs
+        self.tempsPath = buildParameters.buildPath.appending(component: target.c99name + ".build")
+        self.derivedSources = Sources(paths: [], root: tempsPath.appending(component: "DerivedSources"))
 
         if shouldEmitObjCCompatibilityHeader {
             self.moduleMap = try self.generateModuleMap()
         }
+
+        try self.generateResourceAccessor()
+    }
+
+    /// Generate the resource bundle accessor, if appropriate.
+    private func generateResourceAccessor() throws {
+        // Do nothing if we're not generating a bundle.
+        guard let bundleName = target.underlyingTarget.bundleName else { return }
+
+        // Compute the basename of the bundle.
+        let bundleBasename = bundleName + buildParameters.triple.nsbundleExtension
+
+        let stream = BufferedOutputByteStream()
+        stream <<< """
+        import class Foundation.Bundle
+
+        extension Foundation.Bundle {
+            static var moduleResources: Bundle = {
+                return Bundle(path: Bundle.main.bundlePath + "/" + "\(bundleBasename)")!
+            }()
+        }
+        """
+
+        let subpath = RelativePath("resource_bundle_accessor.swift")
+
+        // Add the file to the dervied sources.
+        derivedSources.relativePaths.append(subpath)
+
+        // Write this file out.
+        // FIXME: We should generate this file during the actual build.
+        let path = derivedSources.root.appending(subpath)
+
+        try fs.createDirectory(path.parentDirectory, recursive: true)
+        try fs.writeFileContents(path, bytes: stream.bytes)
     }
 
     /// The arguments needed to compile this target.

Sources/Build/ToolProtocol.swift

@@ -169,7 +169,7 @@ struct SwiftCompilerTool: ToolProtocol {
         stream <<< "    other-args: "
             <<< Format.asJSON(target.compileArguments()) <<< "\n"
         stream <<< "    sources: "
-            <<< Format.asJSON(target.target.sources.paths.map{$0.pathString}) <<< "\n"
+            <<< Format.asJSON(target.sources.map{$0.pathString}) <<< "\n"
         stream <<< "    is-library: "
             <<< Format.asJSON(target.target.type == .library || target.target.type == .test) <<< "\n"
         stream <<< "    enable-whole-module-optimization: "

Sources/Build/Triple.swift

@@ -164,4 +164,15 @@ extension Triple {
             return ".dll"
         }
     }
+
+    /// The file extension for Foundation-style bundle.
+    public var nsbundleExtension: String {
+        switch os {
+        case .darwin, .macOS:
+            return ".bundle"
+        default:
+            // See: https://github.com/apple/swift-corelibs-foundation/blob/master/Docs/FHS%20Bundles.md
+            return ".resources"
+        }
+    }
 }

Sources/Build/llbuild.swift

@@ -240,7 +240,7 @@ public final class LLBuildManifestGenerator {
     private func createSwiftCompileTarget(_ target: SwiftTargetBuildDescription) -> Target {
         // Compute inital inputs.
         var inputs = SortedArray<String>()
-        inputs += target.target.sources.paths.map({ $0.pathString })
+        inputs += target.sources.map{ $0.pathString }
 
         func addStaticTargetInputs(_ target: ResolvedTarget) {
             // Ignore C Modules.

Sources/PackageLoading/PackageBuilder.swift

@@ -724,9 +724,19 @@ public final class PackageBuilder {
             guard !swiftSources.isEmpty else { return nil }
             let swiftSources = Array(swiftSources)
             try validateSourcesOverlapping(forTarget: potentialModule.name, sources: swiftSources)
+
+            // The name of the bundle, if one is being generated.
+            var bundleName: String?
+            // FIXME: This needs to depend on if we have *any* resources, not just explicitly
+            // declared ones.
+            if manifestTarget?.resources.isEmpty == false {
+                bundleName = manifest.name + "_" + potentialModule.name
+            }
+
             // No C sources, so we expect to have Swift sources, and we create a Swift target.
             return SwiftTarget(
                 name: potentialModule.name,
+                bundleName: bundleName,
                 platforms: self.platforms(),
                 isTest: potentialModule.isTest,
                 sources: Sources(paths: swiftSources, root: potentialModule.path),

Sources/PackageModel/Manifest.swift

@@ -238,7 +238,7 @@ public struct TargetDescription: Equatable, Codable {
     public let sources: [String]?
 
     /// The explicitly declared resources of the target.
-    public let resources: [Resource]?
+    public let resources: [Resource]
 
     /// The exclude patterns.
     public let exclude: [String]
@@ -274,7 +274,7 @@ public struct TargetDescription: Equatable, Codable {
         path: String? = nil,
         exclude: [String] = [],
         sources: [String]? = nil,
-        resources: [Resource]? = nil,
+        resources: [Resource] = [],
         publicHeadersPath: String? = nil,
         type: TargetType = .regular,
         pkgConfig: String? = nil,

Sources/PackageModel/Sources.swift

@@ -13,9 +13,13 @@ import TSCUtility
 
 /// A grouping of related source files.
 public struct Sources {
-    public let relativePaths: [RelativePath]
+    /// The root of the sources.
     public let root: AbsolutePath
 
+    /// The subpaths within the root.
+    public var relativePaths: [RelativePath]
+
+    /// The list of absolute paths of all files.
     public var paths: [AbsolutePath] {
         return relativePaths.map({ root.appending($0) })
     }

Sources/PackageModel/Target.swift

@@ -34,6 +34,9 @@ public class Target: ObjectIdentifierProtocol {
     /// The language-level target name.
     public let c99name: String
 
+    /// The bundle name, if one is being generated.
+    public let bundleName: String?
+
     /// Suffix that's expected for test targets.
     public static let testModuleNameSuffix = "Tests"
 
@@ -56,6 +59,7 @@ public class Target: ObjectIdentifierProtocol {
 
     fileprivate init(
         name: String,
+        bundleName: String? = nil,
         platforms: [SupportedPlatform],
         type: Kind,
         sources: Sources,
@@ -64,6 +68,7 @@ public class Target: ObjectIdentifierProtocol {
         buildSettings: BuildSettings.AssignmentTable
     ) {
         self.name = name
+        self.bundleName = bundleName
         self.platforms = platforms
         self.type = type
         self.sources = sources
@@ -127,6 +132,7 @@ public class SwiftTarget: Target {
 
     public init(
         name: String,
+        bundleName: String? = nil,
         platforms: [SupportedPlatform] = [],
         isTest: Bool = false,
         sources: Sources,
@@ -139,6 +145,7 @@ public class SwiftTarget: Target {
         self.swiftVersion = swiftVersion
         super.init(
             name: name,
+            bundleName: bundleName,
             platforms: platforms,
             type: type,
             sources: sources,

Tests/BuildTests/BuildPlanTests.swift

@@ -1749,6 +1749,69 @@ final class BuildPlanTests: XCTestCase {
                 """))
         }
     }
+
+    func testSwiftBundleAccessor() throws {
+        // This has a Swift and ObjC target in the same package.
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/PkgA/Sources/Foo/Foo.swift",
+            "/PkgA/Sources/Foo/foo.txt",
+            "/PkgA/Sources/Foo/bar.txt",
+            "/PkgA/Sources/Bar/Bar.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+
+        let graph = loadPackageGraph(
+            root: "/PkgA",
+            fs: fs,
+            diagnostics: diagnostics,
+            manifests: [
+                Manifest.createManifest(
+                    name: "PkgA",
+                    path: "/PkgA",
+                    url: "/PkgA",
+                    v: .v5_2,
+                    targets: [
+                        TargetDescription(
+                            name: "Foo",
+                            resources: [
+                                .init(rule: .copy, path: "foo.txt"),
+                                .init(rule: .process, path: "bar.txt"),
+                            ]
+                        ),
+                        TargetDescription(
+                            name: "Bar"
+                        ),
+                    ]
+                )
+            ]
+        )
+
+        XCTAssertNoDiagnostics(diagnostics)
+
+        let plan = try BuildPlan(
+            buildParameters: mockBuildParameters(),
+            graph: graph,
+            diagnostics: diagnostics,
+            fileSystem: fs
+        )
+        let result = BuildPlanResult(plan: plan)
+
+        let fooTarget = try result.target(for: "Foo").swiftTarget()
+        XCTAssertEqual(fooTarget.objects.map{ $0.pathString }, [
+            "/path/to/build/debug/Foo.build/Foo.swift.o",
+            "/path/to/build/debug/Foo.build/resource_bundle_accessor.swift.o"
+        ])
+
+        let resourceAccessor = fooTarget.sources.first{ $0.basename == "resource_bundle_accessor.swift" }!
+        let contents = try fs.readFileContents(resourceAccessor).cString
+        XCTAssertTrue(contents.contains("extension Foundation.Bundle"), contents)
+
+        let barTarget = try result.target(for: "Bar").swiftTarget()
+        XCTAssertEqual(barTarget.objects.map{ $0.pathString }, [
+            "/path/to/build/debug/Bar.build/Bar.swift.o",
+        ])
+    }
 }
 
 // MARK:- Test Helpers

Tests/BuildTests/XCTestManifests.swift

@@ -30,6 +30,7 @@ extension BuildPlanTests {
         ("testPlatforms", testPlatforms),
         ("testPlatformsValidation", testPlatformsValidation),
         ("testREPLArguments", testREPLArguments),
+        ("testSwiftBundleAccessor", testSwiftBundleAccessor),
         ("testSwiftCAsmMixed", testSwiftCAsmMixed),
         ("testSwiftCMixed", testSwiftCMixed),
         ("testSystemPackageBuildPlan", testSystemPackageBuildPlan),

Tests/PackageLoadingTests/PD5LoadingTests.swift

@@ -450,8 +450,8 @@ class PackageDescription5LoadingTests: XCTestCase {
 
         loadManifest(stream.bytes, manifestVersion: .v5_2) { manifest in
             let resources = manifest.targets[0].resources
-            XCTAssertEqual(resources?[0], TargetDescription.Resource(rule: .copy, path: "foo.txt"))
-            XCTAssertEqual(resources?[1], TargetDescription.Resource(rule: .process, path: "bar.txt"))
+            XCTAssertEqual(resources[0], TargetDescription.Resource(rule: .copy, path: "foo.txt"))
+            XCTAssertEqual(resources[1], TargetDescription.Resource(rule: .process, path: "bar.txt"))
         }
     }
 }