Handle generated resources from plugins

neonichu · neonichu · commit 98499b4c487a · 2022-04-19T13:06:46.000-07:00
rdar://89693335
diff --git a/Sources/Build/BuildPlan.swift b/Sources/Build/BuildPlan.swift
@@ -174,6 +174,17 @@ public enum TargetBuildDescription {
         }
     }
 
+    /// The resources in this target.
+    var resources: [Resource] {
+        switch self {
+        case .swift(let target):
+            return target.resources
+        case .clang(let target):
+            // FIXME: Clang targets should support generated resources.
+            return target.target.underlyingTarget.resources
+        }
+    }
+
     /// Path to the bundle generated for this module (if any).
     var bundlePath: AbsolutePath? {
         switch self {
@@ -542,16 +553,31 @@ public final class SwiftTargetBuildDescription {
     /// These are the source files derived from plugins.
     private var pluginDerivedSources: Sources
 
+    /// These are the resource files derived from plugins.
+    private var pluginDerivedResources: [Resource]
+
     /// Path to the bundle generated for this module (if any).
     var bundlePath: AbsolutePath? {
-        buildParameters.bundlePath(for: target)
+        if target.underlyingTarget.bundleName != nil {
+            return buildParameters.bundlePath(for: target)
+        } else if !pluginDerivedResources.isEmpty {
+            // FIXME: Use proper bundle name here.
+            return buildParameters.bundlePath(named: "foo_\(target.name)")
+        } else {
+            return nil
+        }
     }
 
     /// The list of all source files in the target, including the derived ones.
     public var sources: [AbsolutePath] {
         target.sources.paths + derivedSources.paths + pluginDerivedSources.paths
     }
 
+    /// The list of all resource files in the target, including the derived ones.
+    public var resources: [Resource] {
+        target.underlyingTarget.resources + pluginDerivedResources
+    }
+
     /// The objects in this target.
     public var objects: [AbsolutePath] {
         let relativePaths = target.sources.relativePaths + derivedSources.relativePaths + pluginDerivedSources.relativePaths
@@ -633,6 +659,9 @@ public final class SwiftTargetBuildDescription {
     /// The results of running any prebuild commands for this target.
     public let prebuildCommandResults: [PrebuildCommandResult]
 
+    /// ObservabilityScope with which to emit diagnostics
+    private let observabilityScope: ObservabilityScope
+
     /// Create a new target description with target and build parameters.
     init(
         target: ResolvedTarget,
@@ -642,7 +671,8 @@ public final class SwiftTargetBuildDescription {
         prebuildCommandResults: [PrebuildCommandResult] = [],
         isTestTarget: Bool? = nil,
         isTestDiscoveryTarget: Bool = false,
-        fileSystem: FileSystem
+        fileSystem: FileSystem,
+        observabilityScope: ObservabilityScope
     ) throws {
         guard target.underlyingTarget is SwiftTarget else {
             throw InternalError("underlying target type mismatch \(target)")
@@ -657,24 +687,46 @@ public final class SwiftTargetBuildDescription {
         self.tempsPath = buildParameters.buildPath.appending(component: target.c99name + ".build")
         self.derivedSources = Sources(paths: [], root: tempsPath.appending(component: "DerivedSources"))
         self.pluginDerivedSources = Sources(paths: [], root: buildParameters.dataPath)
+        self.pluginDerivedResources = []
         self.buildToolPluginInvocationResults = buildToolPluginInvocationResults
         self.prebuildCommandResults = prebuildCommandResults
+        self.observabilityScope = observabilityScope
+
+        func handlePluginDerivedFile(path absPath: AbsolutePath) {
+            // FIXME: Carry `additionalFileRules` until here.
+            let rule = TargetSourcesBuilder.computeRule(for: absPath, toolsVersion: toolsVersion, additionalFileRules: [], observabilityScope: observabilityScope)
+            print("Determined \(rule) for generated file at \(absPath)")
+            switch rule {
+            case .compile:
+                if absPath.extension == "swift" {
+                    let relPath = absPath.relative(to: self.pluginDerivedSources.root)
+                    self.pluginDerivedSources.relativePaths.append(relPath)
+                } else {
+                    // FIXME: Error for unsupported source file type.
+                }
+            case .copy, .processResource:
+                if let resource = TargetSourcesBuilder.resource(for: absPath, with: rule, defaultLocalization: target.defaultLocalization, targetName: target.name, targetPath: target.underlyingTarget.path, observabilityScope: observabilityScope) {
+                    self.pluginDerivedResources.append(resource)
+                } else {
+                    // FIXME: Error for not obtaining a `Resource` object for a file.
+                }
+            case .header, .ignored, .modulemap, .none:
+                break // Ignored for now.
+            }
+        }
 
         // Add any derived source files that were declared for any commands from plugin invocations.
         for command in buildToolPluginInvocationResults.reduce([], { $0 + $1.buildCommands }) {
-            // TODO: What should we do if we find non-Swift sources here?
             for absPath in command.outputFiles {
-                let relPath = absPath.relative(to: self.pluginDerivedSources.root)
-                self.pluginDerivedSources.relativePaths.append(relPath)
+                handlePluginDerivedFile(path: absPath)
             }
         }
 
         // Add any derived source files that were discovered from output directories of prebuild commands.
         for result in self.prebuildCommandResults {
-            // TODO: What should we do if we find non-Swift sources here?
+            // FIXME: `derivedSourceFiles` should probably be renamed here.
             for path in result.derivedSourceFiles {
-                let relPath = path.relative(to: self.pluginDerivedSources.root)
-                self.pluginDerivedSources.relativePaths.append(relPath)
+                handlePluginDerivedFile(path: path)
             }
         }
 
@@ -1585,7 +1637,8 @@ public class BuildPlan {
                     toolsVersion: toolsVersion,
                     buildParameters: buildParameters,
                     isTestTarget: true,
-                    fileSystem: fileSystem
+                    fileSystem: fileSystem,
+                    observabilityScope: observabilityScope
                 )
 
                 result.append((testProduct, desc))
@@ -1621,7 +1674,8 @@ public class BuildPlan {
                     buildParameters: buildParameters,
                     isTestTarget: true,
                     isTestDiscoveryTarget: true,
-                    fileSystem: fileSystem
+                    fileSystem: fileSystem,
+                    observabilityScope: observabilityScope
                 )
 
                 result.append((testProduct, target))
@@ -1703,7 +1757,8 @@ public class BuildPlan {
                     buildParameters: buildParameters,
                     buildToolPluginInvocationResults: buildToolPluginInvocationResults[target] ?? [],
                     prebuildCommandResults: prebuildCommandResults[target] ?? [],
-                    fileSystem: fileSystem)
+                    fileSystem: fileSystem,
+                    observabilityScope: observabilityScope)
                 )
             case is ClangTarget:
                 targetMap[target] = try .clang(ClangTargetBuildDescription(
@@ -2238,9 +2293,11 @@ private extension Basics.Diagnostic {
 extension BuildParameters {
     /// Returns a target's bundle path inside the build directory.
     fileprivate func bundlePath(for target: ResolvedTarget) -> AbsolutePath? {
-        target.underlyingTarget.bundleName
-        .map{ $0 + triple.nsbundleExtension }
-        .map(buildPath.appending(component:))
+        target.underlyingTarget.bundleName.map(bundlePath(named:))
+    }
+
+    fileprivate func bundlePath(named: String) -> AbsolutePath {
+        return buildPath.appending(component: named + triple.nsbundleExtension)
     }
 }
 
diff --git a/Sources/Build/LLBuildManifestBuilder.swift b/Sources/Build/LLBuildManifestBuilder.swift
@@ -171,7 +171,7 @@ extension LLBuildManifestBuilder {
         let infoPlistDestination = RelativePath("Info.plist")
 
         // Create a copy command for each resource file.
-        for resource in target.target.underlyingTarget.resources {
+        for resource in target.resources {
             let destination = bundlePath.appending(resource.destination)
             let (_, output) = addCopyCommand(from: resource.path, to: destination)
             outputs.append(output)
diff --git a/Sources/PackageLoading/PackageBuilder.swift b/Sources/PackageLoading/PackageBuilder.swift
@@ -767,7 +767,7 @@ public final class PackageBuilder {
 
         // FIXME: use identity instead?
         // The name of the bundle, if one is being generated.
-        let bundleName = resources.isEmpty ? nil : self.manifest.displayName + "_" + potentialModule.name
+        let potentialBundleName = self.manifest.displayName + "_" + potentialModule.name
 
         if sources.relativePaths.isEmpty && resources.isEmpty {
             return nil
@@ -808,8 +808,9 @@ public final class PackageBuilder {
         if sources.hasSwiftSources {
             return SwiftTarget(
                 name: potentialModule.name,
-                bundleName: bundleName,
+                potentialBundleName: potentialBundleName,
                 type: targetType,
+                path: potentialModule.path,
                 sources: sources,
                 resources: resources,
                 ignored: ignored,
@@ -836,13 +837,14 @@ public final class PackageBuilder {
 
             return try ClangTarget(
                 name: potentialModule.name,
-                bundleName: bundleName,
+                potentialBundleName: potentialBundleName,
                 cLanguageStandard: manifest.cLanguageStandard,
                 cxxLanguageStandard: manifest.cxxLanguageStandard,
                 includeDir: publicHeadersPath,
                 moduleMapType: moduleMapType,
                 headers: headers,
                 type: targetType,
+                path: potentialModule.path,
                 sources: sources,
                 resources: resources,
                 ignored: ignored,
@@ -1362,6 +1364,7 @@ extension PackageBuilder {
                 return SwiftTarget(
                     name: name,
                     type: .snippet,
+                    path: .root,
                     sources: sources,
                     dependencies: dependencies,
                     swiftVersion: try swiftVersion(),
diff --git a/Sources/PackageLoading/TargetSourcesBuilder.swift b/Sources/PackageLoading/TargetSourcesBuilder.swift
@@ -75,9 +75,7 @@ public struct TargetSourcesBuilder {
         self.target = target
         self.defaultLocalization = defaultLocalization
         self.targetPath = path
-        // In version 5.4 and earlier, SwiftPM did not support `additionalFileRules` and always implicitly included XCBuild file types.
-        let actualAdditionalRules = (toolsVersion <= ToolsVersion.v5_4 ? FileRuleDescription.xcbuildFileTypes : additionalFileRules)
-        self.rules = FileRuleDescription.builtinRules + actualAdditionalRules
+        self.rules = Self.rules(additionalFileRules: additionalFileRules, toolsVersion: toolsVersion)
         self.toolsVersion = toolsVersion
         let excludedPaths = target.exclude.map { AbsolutePath($0, relativeTo: path) }
         self.excludedPaths = Set(excludedPaths)
@@ -125,6 +123,12 @@ public struct TargetSourcesBuilder {
       #endif
     }
 
+    private static func rules(additionalFileRules: [FileRuleDescription], toolsVersion: ToolsVersion) -> [FileRuleDescription] {
+        // In version 5.4 and earlier, SwiftPM did not support `additionalFileRules` and always implicitly included XCBuild file types.
+        let actualAdditionalRules = (toolsVersion <= ToolsVersion.v5_4 ? FileRuleDescription.xcbuildFileTypes : additionalFileRules)
+        return FileRuleDescription.builtinRules + actualAdditionalRules
+    }
+
     @discardableResult
     private func validTargetPath(at: AbsolutePath) -> Error? {
         // Check if paths that are enumerated in targets: [] exist
@@ -185,26 +189,32 @@ public struct TargetSourcesBuilder {
     }
 
     /// Compute the rule for the given path.
-    private func computeRule(for path: AbsolutePath) -> FileRuleDescription.Rule {
+    public static func computeRule(for path: AbsolutePath, toolsVersion: ToolsVersion, additionalFileRules: [FileRuleDescription], observabilityScope: ObservabilityScope) -> FileRuleDescription.Rule {
+        let rules = Self.rules(additionalFileRules: additionalFileRules, toolsVersion: toolsVersion)
+        // For now, we are not passing in any declared resources or sources here and instead handle any generated files automatically at the callsite. Eventually, we will want the ability to declare opinions for generated files in the manifest as well.
+        return Self.computeRule(for: path, toolsVersion: toolsVersion, rules: rules, declaredResources: [], declaredSources: nil, observabilityScope: observabilityScope)
+    }
+
+    private static func computeRule(for path: AbsolutePath, toolsVersion: ToolsVersion, rules: [FileRuleDescription], declaredResources: [(path: AbsolutePath, rule: TargetDescription.Resource.Rule)], declaredSources: [AbsolutePath]?, observabilityScope: ObservabilityScope) -> FileRuleDescription.Rule {
         var matchedRule: FileRuleDescription.Rule = .none
 
         // First match any resources explicitly declared in the manifest file.
-        for declaredResource in target.resources {
-            let resourcePath = AbsolutePath(declaredResource.path, relativeTo: self.targetPath)
+        for declaredResource in declaredResources {
+            let resourcePath = declaredResource.path
             if path.isDescendantOfOrEqual(to: resourcePath) {
                 if matchedRule != .none {
-                    self.observabilityScope.emit(error: "duplicate resource rule '\(declaredResource.rule)' found for file at '\(path)'")
+                    observabilityScope.emit(error: "duplicate resource rule '\(declaredResource.rule)' found for file at '\(path)'")
                 }
                 matchedRule = .init(declaredResource.rule)
             }
         }
 
         // Match any sources explicitly declared in the manifest file.
-        if let declaredSources = self.declaredSources {
+        if let declaredSources = declaredSources {
             for sourcePath in declaredSources {
                 if path.isDescendantOfOrEqual(to: sourcePath) {
                     if matchedRule != .none {
-                        self.observabilityScope.emit(error: "duplicate rule found for file at '\(path)'")
+                        observabilityScope.emit(error: "duplicate rule found for file at '\(path)'")
                     }
 
                     // Check for header files as they're allowed to be mixed with sources.
@@ -231,10 +241,10 @@ public struct TargetSourcesBuilder {
             let effectiveRules: [FileRuleDescription] = {
                 // Don't automatically match compile rules if target's sources are
                 // explicitly declared in the package manifest.
-                if target.sources != nil {
-                    return self.rules.filter { $0.rule != .compile }
+                if declaredSources != nil {
+                    return rules.filter { $0.rule != .compile }
                 }
-                return self.rules
+                return rules
             }()
 
             if let needle = effectiveRules.first(where: { $0.match(path: path, toolsVersion: toolsVersion) }) {
@@ -247,8 +257,13 @@ public struct TargetSourcesBuilder {
         return matchedRule
     }
 
+    private func computeRule(for path: AbsolutePath) -> FileRuleDescription.Rule {
+        let declaredResources = target.resources.map { (path: AbsolutePath($0.path, relativeTo: self.targetPath), rule: $0.rule) }
+        return Self.computeRule(for: path, toolsVersion: toolsVersion, rules: rules, declaredResources: declaredResources, declaredSources: declaredSources, observabilityScope: observabilityScope)
+    }
+
     /// Returns the `Resource` file associated with a file and a particular rule, if there is one.
-    private func resource(for path: AbsolutePath, with rule: FileRuleDescription.Rule) -> Resource? {
+    public static func resource(for path: AbsolutePath, with rule: FileRuleDescription.Rule, defaultLocalization: String?, targetName: String, targetPath: AbsolutePath, observabilityScope: ObservabilityScope) -> Resource? {
         switch rule {
         case .compile, .header, .none, .modulemap, .ignored:
             return nil
@@ -275,7 +290,7 @@ public struct TargetSourcesBuilder {
             // If a resource is both inside a localization directory and has an explicit localization, it's ambiguous.
             guard implicitLocalization == nil || explicitLocalization == nil else {
                 let relativePath = path.relative(to: targetPath)
-                self.observabilityScope.emit(.localizationAmbiguity(path: relativePath, targetName: target.name))
+                observabilityScope.emit(.localizationAmbiguity(path: relativePath, targetName: targetName))
                 return nil
             }
 
@@ -285,6 +300,10 @@ public struct TargetSourcesBuilder {
         }
     }
 
+    private func resource(for path: AbsolutePath, with rule: FileRuleDescription.Rule) -> Resource? {
+        return Self.resource(for: path, with: rule, defaultLocalization: defaultLocalization, targetName: target.name, targetPath: targetPath, observabilityScope: observabilityScope)
+    }
+
     private func diagnoseConflictingResources(in resources: [Resource]) {
         let duplicateResources = resources.spm_findDuplicateElements(by: \.destination)
         for resources in duplicateResources {
diff --git a/Sources/PackageModel/Target.swift b/Sources/PackageModel/Target.swift
diff --git a/Tests/PackageGraphTests/TargetTests.swift b/Tests/PackageGraphTests/TargetTests.swift
