fix: fixed Path deprecation warnings in package plugin (#140)

Author: soumyamahunt

Plugins/MetaProtocolCodable/Config.swift

@@ -80,15 +80,56 @@ extension Config: Codable {
     /// - Returns: The file path URL.
     static func url(forFilePath filePath: String) -> URL {
         #if canImport(Darwin)
-        if #available(macOS 13, iOS 16, macCatalyst 16, tvOS 16, watchOS 9, *) {
-            return URL(filePath: filePath)
-        } else {
+        guard
+            #available(macOS 13, iOS 16, macCatalyst 16, tvOS 16, watchOS 9, *)
+        else {
             return URL(fileURLWithPath: filePath)
         }
+        return URL(filePath: filePath)
         #else
         return URL(fileURLWithPath: filePath)
         #endif
     }
+
+    /// Returns file path as string converting provided URL.
+    ///
+    /// Uses platform and version specific API to create string file path.
+    ///
+    /// - Parameter url: The path to file as URL.
+    /// - Returns: The file path string.
+    static func filePath(forURL url: URL) -> String {
+        #if canImport(Darwin)
+        guard
+            #available(macOS 13, iOS 16, macCatalyst 16, tvOS 16, watchOS 9, *)
+        else {
+            return url.path
+        }
+        return url.path(percentEncoded: false)
+        #else
+        return url.path
+        #endif
+    }
+
+    /// Returns a URL by appending the specified path to the URL.
+    ///
+    /// This method doesn’t percent-encode any path separators.
+    ///
+    /// - Parameters:
+    ///   - path: The path component to append to the URL.
+    ///   - url: The base URL to which the path will be appended.
+    /// - Returns: A new URL with the path component appended.
+    static func appending(path: String, to url: URL) -> URL {
+        #if canImport(Darwin)
+        guard
+            #available(macOS 13, iOS 16, macCatalyst 16, tvOS 16, watchOS 9, *)
+        else {
+            return url.appendingPathComponent(path)
+        }
+        return url.appending(path: path)
+        #else
+        return url.appendingPathComponent(path)
+        #endif
+    }
 }
 
 extension KeyedDecodingContainerProtocol {

Plugins/MetaProtocolCodable/PathToURLMigration.swift

@@ -0,0 +1,117 @@
+import Foundation
+import PackagePlugin
+
+#if swift(<6)
+extension PluginContext.Tool {
+    /// Full path of the built or provided tool in the file system.
+    var url: URL {
+        Config.url(forFilePath: path.string)
+    }
+}
+
+extension PackagePlugin.File {
+    /// The path of the file.
+    var url: URL {
+        Config.url(forFilePath: path.string)
+    }
+}
+
+extension PluginContext {
+    /// The path of a writable directory into which the plugin or the build
+    /// commands it constructs can write anything it wants. This could include
+    /// any generated source files that should be processed further, and it
+    /// could include any caches used by the build tool or the plugin itself.
+    /// The plugin is in complete control of what is written under this di-
+    /// rectory, and the contents are preserved between builds.
+    ///
+    /// A plugin would usually create a separate subdirectory of this directory
+    /// for each command it creates, and the command would be configured to
+    /// write its outputs to that directory. The plugin may also create other
+    /// directories for cache files and other file system content that either
+    /// it or the command will need.
+    var pluginWorkDirectoryURL: URL {
+        Config.url(forFilePath: pluginWorkDirectory.string)
+    }
+}
+
+extension Command {
+    /// Returns a command that runs when any of its output files are needed by
+    /// the build, but out-of-date.
+    ///
+    /// An output file is out-of-date if it doesn't exist, or if any input files
+    /// have changed since the command was last run.
+    ///
+    /// - Note: the paths in the list of output files may depend on the list of
+    ///   input file paths, but **must not** depend on reading the contents of
+    ///   any input files. Such cases must be handled using a `prebuildCommand`.
+    ///
+    /// - parameters:
+    ///   - displayName: An optional string to show in build logs and other
+    ///     status areas.
+    ///   - executable: The absolute path to the executable to be invoked.
+    ///   - arguments: Command-line arguments to be passed to the executable.
+    ///   - environment: Environment variable assignments visible to the
+    ///     executable.
+    ///   - inputFiles: Files on which the contents of output files may depend.
+    ///     Any paths passed as `arguments` should typically be passed here as
+    ///     well.
+    ///   - outputFiles: Files to be generated or updated by the executable.
+    ///     Any files recognizable by their extension as source files
+    ///     (e.g. `.swift`) are compiled into the target for which this command
+    ///     was generated as if in its source directory; other files are treated
+    ///     as resources as if explicitly listed in `Package.swift` using
+    ///     `.process(...)`.
+    static func buildCommand(
+        displayName: String?, executable: URL, arguments: [String],
+        environment: [String: String] = [:], inputFiles: [URL] = [],
+        outputFiles: [URL] = []
+    ) -> Self {
+        .buildCommand(
+            displayName: displayName,
+            executable: .init(Config.filePath(forURL: executable)),
+            arguments: arguments,
+            environment: environment,
+            inputFiles: inputFiles.map { .init(Config.filePath(forURL: $0)) },
+            outputFiles: outputFiles.map { .init(Config.filePath(forURL: $0)) }
+        )
+    }
+}
+
+#if canImport(XcodeProjectPlugin)
+extension XcodePluginContext {
+    /// The path of a writable directory into which the plugin or the build
+    /// commands it constructs can write anything it wants. This could include
+    /// any generated source files that should be processed further, and it
+    /// could include any caches used by the build tool or the plugin itself.
+    /// The plugin is in complete control of what is written under this di-
+    /// rectory, and the contents are preserved between builds.
+    ///
+    /// A plugin would usually create a separate subdirectory of this directory
+    /// for each command it creates, and the command would be configured to
+    /// write its outputs to that directory. The plugin may also create other
+    /// directories for cache files and other file system content that either
+    /// it or the command will need.
+    var pluginWorkDirectoryURL: URL {
+        Config.url(forFilePath: pluginWorkDirectory.string)
+    }
+}
+#endif
+#endif
+
+extension SourceModuleTarget {
+    /// The absolute path of the target directory in the local file system.
+    var directoryURL: URL {
+        #if swift(<6)
+        return Config.url(forFilePath: directory.string)
+        #else
+        switch self {
+        case let target as ClangSourceModuleTarget:
+            return target.directoryURL
+        case let target as SwiftSourceModuleTarget:
+            return target.directoryURL
+        default:
+            fatalError("Unsupported target type")
+        }
+        #endif
+    }
+}

Plugins/MetaProtocolCodable/Plugin.swift

@@ -20,9 +20,8 @@ struct MetaProtocolCodable: BuildToolPlugin {
     func fetchConfig<Target: MetaProtocolCodableSourceTarget>(
         for target: Target
     ) throws -> Config {
-        let pathStr = try target.configPath(named: "metacodableconfig")
-        guard let pathStr else { return .init(scan: .target) }
-        let path = Config.url(forFilePath: pathStr)
+        let path = try target.configPath(named: "metacodableconfig")
+        guard let path = path else { return .init(scan: .target) }
         let conf = try Data(contentsOf: path)
         let pConf = try? PropertyListDecoder().decode(Config.self, from: conf)
         let config = try pConf ?? JSONDecoder().decode(Config.self, from: conf)
@@ -50,32 +49,35 @@ struct MetaProtocolCodable: BuildToolPlugin {
         let (allTargets, imports) = config.scanInput(for: target, in: context)
 
         // Setup folder
-        let genFolder = context.pluginWorkDirectory.appending(["ProtocolGen"])
+        let genFolder = Config.appending(
+            path: "ProtocolGen", to: context.pluginWorkDirectoryURL
+        )
         try FileManager.default.createDirectory(
-            atPath: genFolder.string, withIntermediateDirectories: true
+            at: genFolder, withIntermediateDirectories: true
         )
 
         // Create source scan commands
-        var intermFiles: [Path] = []
+        var intermFiles: [URL] = []
         var buildCommands = allTargets.flatMap { target in
             return target.sourceFiles(withSuffix: "swift").map { file in
                 let moduleName = target.moduleName
-                let fileName = file.path.stem
+                let fileName = file.url.deletingPathExtension()
+                    .lastPathComponent
                 let genFileName = "\(moduleName)-\(fileName)-gen.json"
-                let genFile = genFolder.appending([genFileName])
+                let genFile = Config.appending(path: genFileName, to: genFolder)
                 intermFiles.append(genFile)
                 return Command.buildCommand(
                     displayName: """
                         Parse source file "\(fileName)" in module "\(moduleName)"
                         """,
-                    executable: tool.path,
+                    executable: tool.url,
                     arguments: [
                         "parse",
-                        file.path.string,
+                        Config.filePath(forURL: file.url),
                         "--output",
-                        genFile.string,
+                        Config.filePath(forURL: genFile),
                     ],
-                    inputFiles: [file.path],
+                    inputFiles: [file.url],
                     outputFiles: [genFile]
                 )
             }
@@ -84,20 +86,22 @@ struct MetaProtocolCodable: BuildToolPlugin {
         // Create syntax generation command
         let moduleName = target.moduleName
         let genFileName = "\(moduleName)+ProtocolHelperCoders.swift"
-        let genPath = genFolder.appending(genFileName)
-        var genArgs = ["generate", "--output", genPath.string]
+        let genPath = Config.appending(path: genFileName, to: genFolder)
+        var genArgs = [
+            "generate", "--output", Config.filePath(forURL: genPath),
+        ]
         for `import` in imports {
             genArgs.append(contentsOf: ["--module", `import`])
         }
         for file in intermFiles {
-            genArgs.append(file.string)
+            genArgs.append(Config.filePath(forURL: file))
         }
         buildCommands.append(
             .buildCommand(
                 displayName: """
                     Generate protocol decoding/encoding syntax for "\(moduleName)"
                     """,
-                executable: tool.path,
+                executable: tool.url,
                 arguments: genArgs,
                 inputFiles: intermFiles,
                 outputFiles: [genPath]
@@ -147,7 +151,7 @@ extension MetaProtocolCodable: XcodeBuildToolPlugin {
     func createBuildCommands(
         context: XcodePluginContext, target: XcodeTarget
     ) throws -> [Command] {
-        return try self.createBuildCommands(
+        try self.createBuildCommands(
             in: context, for: target
         )
     }

Plugins/MetaProtocolCodable/PluginContext.swift

@@ -1,3 +1,4 @@
+import Foundation
 import PackagePlugin
 
 /// Provides information about the package for which the plugin is invoked,
@@ -23,7 +24,7 @@ protocol MetaProtocolCodablePluginContext {
     /// write its outputs to that directory. The plugin may also create other
     /// directories for cache files and other file system content that either
     /// it or the command will need.
-    var pluginWorkDirectory: Path { get }
+    var pluginWorkDirectoryURL: URL { get }
     /// The targets which are local to current context.
     ///
     /// These targets are included in the same package/project as this context.
@@ -45,7 +46,7 @@ extension PluginContext: MetaProtocolCodablePluginContext {
     ///
     /// Includes all the source code targets of the package.
     var localTargets: [SwiftPackageTarget] {
-        return `package`.targets.compactMap { target in
+        `package`.targets.compactMap { target in
             guard let sourceModule = target.sourceModule else { return nil }
             return SwiftPackageTarget(module: sourceModule)
         }

Plugins/MetaProtocolCodable/SourceTarget/MetaProtocolCodableSourceTarget.swift

@@ -1,3 +1,4 @@
+import Foundation
 import PackagePlugin
 
 /// Represents a target consisting of a source code module,
@@ -42,7 +43,7 @@ protocol MetaProtocolCodableSourceTarget {
     ///
     /// - Parameter name: The config file name.
     /// - Returns: The config file path.
-    func configPath(named name: String) throws -> String?
+    func configPath(named name: String) throws -> URL?
 }
 
 extension Config {
@@ -71,12 +72,12 @@ extension Config {
             allTargets = targets
         case .local:
             allTargets = context.localTargets.filter { localTarget in
-                return target.recursiveTargets.contains { target in
-                    return target.moduleName == localTarget.moduleName
+                target.recursiveTargets.contains { target in
+                    target.moduleName == localTarget.moduleName
                 }
             }
             modules = allTargets.lazy.map(\.moduleName).filter { module in
-                return module != target.moduleName
+                module != target.moduleName
             }
         case .recursive:
             var targets = target.recursiveTargets

Plugins/MetaProtocolCodable/SourceTarget/SwiftPackageTarget.swift

@@ -22,7 +22,7 @@ extension SwiftPackageTarget: MetaProtocolCodableSourceTarget {
     ///
     /// Represents direct dependencies of the target.
     var dependencyTargets: [Self] {
-        return module.dependencies.lazy.compactMap { dependency in
+        module.dependencies.lazy.compactMap { dependency in
             return switch dependency {
             case .target(let target):
                 target.sourceModule
@@ -36,7 +36,7 @@ extension SwiftPackageTarget: MetaProtocolCodableSourceTarget {
     ///
     /// Represents direct and transient dependencies of the target.
     var recursiveTargets: [Self] {
-        return module.recursiveTargetDependencies.lazy
+        module.recursiveTargetDependencies.lazy
             .compactMap { $0.sourceModule }
             .map { Self.init(module: $0) }
     }
@@ -49,7 +49,7 @@ extension SwiftPackageTarget: MetaProtocolCodableSourceTarget {
     /// - Parameter suffix: The name suffix.
     /// - Returns: The matching files.
     func sourceFiles(withSuffix suffix: String) -> FileList {
-        return module.sourceFiles(withSuffix: suffix)
+        module.sourceFiles(withSuffix: suffix)
     }
 
     /// The absolute path to config file if provided.
@@ -62,19 +62,18 @@ extension SwiftPackageTarget: MetaProtocolCodableSourceTarget {
     ///
     /// - Parameter name: The config file name.
     /// - Returns: The config file path.
-    func configPath(named name: String) throws -> String? {
+    func configPath(named name: String) throws -> URL? {
         let fileManager = FileManager.default
-        let directory = module.directory.string
-        let contents = try fileManager.contentsOfDirectory(atPath: directory)
-        let file = contents.first { file in
-            let path = Path(file)
-            return name.lowercased()
-                == path.stem
+        let directory = module.directoryURL
+        let contents = try fileManager.contentsOfDirectory(
+            at: directory, includingPropertiesForKeys: nil
+        )
+        return contents.first { file in
+            name.lowercased()
+                == file.deletingPathExtension().lastPathComponent
                 .components(separatedBy: .alphanumerics.inverted)
                 .joined(separator: "")
                 .lowercased()
         }
-        guard let file else { return nil }
-        return module.directory.appending([file]).string
     }
 }