Fix path handling for plugins on Windows

Due to RFC8089 compliance changes for Foundation.URL in Swift 6, URL.path does _NOT_ behave as one might expect, producing a path with a leading slash which will be interpreted by Windows as relative.

Closes #6851

Author: jakepetroules

Sources/Basics/CMakeLists.txt

@@ -72,6 +72,7 @@ add_library(Basics
   SQLiteBackedCache.swift
   TestingLibrary.swift
   Triple+Basics.swift
+  URL.swift
   Version+Extensions.swift
   WritableByteStream+Extensions.swift
   Vendor/Triple.swift

Sources/Basics/URL.swift

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct Foundation.URL
+
+extension URL {
+    /// Returns the path of the file URL.
+    ///
+    /// This should always be used whenever the file path equivalent of a URL is needed. DO NOT use ``path`` or ``path(percentEncoded:)``, as these deal in terms of the path portion of the URL representation per RFC8089, which on Windows would include a leading slash.
+    ///
+    /// - throws: ``FileURLError`` if the URL does not represent a file or its path is otherwise not representable.
+    public var filePath: AbsolutePath {
+        get throws {
+            guard isFileURL else {
+                throw FileURLError.notRepresentable(self)
+            }
+            return try withUnsafeFileSystemRepresentation { cString in
+                guard let cString else {
+                    throw FileURLError.notRepresentable(self)
+                }
+                return try AbsolutePath(validating: String(cString: cString))
+            }
+        }
+    }
+}
+
+fileprivate enum FileURLError: Error {
+    case notRepresentable(URL)
+}

Sources/PackagePlugin/Context.swift

@@ -63,17 +63,18 @@ public struct PluginContext {
             if let triples = tool.triples, triples.isEmpty {
                 throw PluginContextError.toolNotSupportedOnTargetPlatform(name: name)
             }
-            return Tool(name: name, path: Path(url: tool.path), url: tool.path)
+            return try Tool(name: name, path: Path(url: tool.path), url: tool.path)
         } else {
             for dir in self.toolSearchDirectoryURLs {
                 #if os(Windows)
                 let hostExecutableSuffix = ".exe"
                 #else
                 let hostExecutableSuffix = ""
                 #endif
-                let path = dir.appendingPathComponent(name + hostExecutableSuffix)
-                if FileManager.default.isExecutableFile(atPath: path.path) {
-                    return Tool(name: name, path: Path(url: path), url: path)
+                let pathURL = dir.appendingPathComponent(name + hostExecutableSuffix)
+                let path = try Path(url: pathURL)
+                if FileManager.default.isExecutableFile(atPath: path.stringValue) {
+                    return Tool(name: name, path: path, url: pathURL)
                 }
             }
         }

Sources/PackagePlugin/PackageManagerProxy.swift

@@ -113,7 +113,7 @@ public struct PackageManager {
             /// Full path of the built artifact in the local file system.
             @available(_PackageDescription, deprecated: 6.0, renamed: "url")
             public var path: Path {
-                Path(url: self.url)
+                try! Path(url: self.url)
             }
 
             /// Full path of the built artifact in the local file system.
@@ -187,7 +187,7 @@ public struct PackageManager {
         /// `llvm-cov`, if `enableCodeCoverage` was set in the test parameters.
         @available(_PackageDescription, deprecated: 6.0, renamed: "codeCoverageDataFileURL")
         public var codeCoverageDataFile: Path? {
-            self.codeCoverageDataFileURL.map { Path(url: $0) }
+            self.codeCoverageDataFileURL.map { try! Path(url: $0) }
         }
 
         /// Path of a generated `.profdata` file suitable for processing using
@@ -275,7 +275,7 @@ public struct PackageManager {
         /// The directory that contains the symbol graph files for the target.
         @available(_PackageDescription, deprecated: 6.0, renamed: "directoryURL")
         public var directoryPath: Path {
-            Path(url: self.directoryURL)
+            try! Path(url: self.directoryURL)
         }
 
         /// The directory that contains the symbol graph files for the target.

Sources/PackagePlugin/Path.swift

@@ -23,8 +23,8 @@ public struct Path: Hashable {
         self._string = string
     }
 
-    init(url: URL) {
-        self._string = url.path
+    init(url: URL) throws {
+        self._string = try url.filePath
     }
 
     /// A string representation of the path.
@@ -157,3 +157,28 @@ extension String.StringInterpolation {
         self.appendInterpolation(path.string)
     }
 }
+
+extension URL {
+    /// Returns the path of the file URL.
+    ///
+    /// This should always be used whenever the file path equivalent of a URL is needed. DO NOT use ``path`` or ``path(percentEncoded:)``, as these deal in terms of the path portion of the URL representation per RFC8089, which on Windows would include a leading slash.
+    ///
+    /// - throws: ``FileURLError`` if the URL does not represent a file or its path is otherwise not representable.
+    fileprivate var filePath: String {
+        get throws {
+            guard isFileURL else {
+                throw FileURLError.notRepresentable(self)
+            }
+            return try withUnsafeFileSystemRepresentation { cString in
+                guard let cString else {
+                    throw FileURLError.notRepresentable(self)
+                }
+                return String(cString: cString)
+            }
+        }
+    }
+}
+
+fileprivate enum FileURLError: Error {
+    case notRepresentable(URL)
+}

Sources/PackagePlugin/Plugin.swift

@@ -158,12 +158,12 @@ extension Plugin {
                     return (path, tool.triples)
                 }
 
-                context = PluginContext(
+                context = try PluginContext(
                     package: package,
                     pluginWorkDirectory: Path(url: pluginWorkDirectory),
                     pluginWorkDirectoryURL: pluginWorkDirectory,
                     accessibleTools: accessibleTools,
-                    toolSearchDirectories: toolSearchDirectories.map { Path(url: $0) },
+                    toolSearchDirectories: toolSearchDirectories.map { try Path(url: $0) },
                     toolSearchDirectoryURLs: toolSearchDirectories)
 
                 let pluginGeneratedSources = try generatedSources.map { try deserializer.url(for: $0) }
@@ -248,12 +248,12 @@ extension Plugin {
                     let path = try deserializer.url(for: tool.path)
                     return (path, tool.triples)
                 }
-                context = PluginContext(
+                context = try PluginContext(
                     package: package,
                     pluginWorkDirectory: Path(url: pluginWorkDirectory),
                     pluginWorkDirectoryURL: pluginWorkDirectory,
                     accessibleTools: accessibleTools,
-                    toolSearchDirectories: toolSearchDirectories.map { Path(url: $0) },
+                    toolSearchDirectories: toolSearchDirectories.map { try Path(url: $0) },
                     toolSearchDirectoryURLs: toolSearchDirectories)
             }
             catch {

Sources/PackagePlugin/PluginContextDeserializer.swift

@@ -42,8 +42,18 @@ internal struct PluginContextDeserializer {
 
         // Compose a path based on an optional base path and a subpath.
         let wirePath = wireInput.paths[id]
-        let basePath = try wireInput.paths[id].baseURLId.map{ try self.url(for: $0) } ?? URL(fileURLWithPath: "/")
-        let path = basePath.appendingPathComponent(wirePath.subpath)
+        let basePath = try wireInput.paths[id].baseURLId.map{ try self.url(for: $0) }
+        let path: URL
+        if let basePath {
+            path = basePath.appendingPathComponent(wirePath.subpath)
+        } else {
+            #if os(Windows)
+            // Windows does not have a single root path like UNIX, if this component has no base path, it IS the root and should not be joined with anything
+            path = URL(fileURLWithPath: wirePath.subpath)
+            #else
+            path = URL(fileURLWithPath: "/").appendingPathComponent(wirePath.subpath)
+            #endif
+        }
 
         // Store it for the next look up.
         urlsById[id] = path
@@ -92,9 +102,9 @@ internal struct PluginContextDeserializer {
                 case .unknown:
                     type = .unknown
                 }
-                return File(path: Path(url: path), url: path, type: type)
+                return try File(path: Path(url: path), url: path, type: type)
             })
-            target = SwiftSourceModuleTarget(
+            target = try SwiftSourceModuleTarget(
                 id: String(id),
                 name: wireTarget.name,
                 kind: .init(kind),
@@ -125,9 +135,9 @@ internal struct PluginContextDeserializer {
                 case .unknown:
                     type = .unknown
                 }
-                return File(path: Path(url: path), url: path, type: type)
+                return try File(path: Path(url: path), url: path, type: type)
             })
-            target = ClangSourceModuleTarget(
+            target = try ClangSourceModuleTarget(
                 id: String(id),
                 name: wireTarget.name,
                 kind: .init(kind),
@@ -138,7 +148,7 @@ internal struct PluginContextDeserializer {
                 sourceFiles: sourceFiles,
                 preprocessorDefinitions: preprocessorDefinitions,
                 headerSearchPaths: headerSearchPaths,
-                publicHeadersDirectory: publicHeadersDir.map { .init(url: $0) },
+                publicHeadersDirectory: publicHeadersDir.map { try .init(url: $0) },
                 publicHeadersDirectoryURL: publicHeadersDir,
                 linkedLibraries: linkedLibraries,
                 linkedFrameworks: linkedFrameworks,
@@ -162,7 +172,7 @@ internal struct PluginContextDeserializer {
             case .remote(let url):
                 artifactOrigin = .remote(url: url)
             }
-            target = BinaryArtifactTarget(
+            target = try BinaryArtifactTarget(
                 id: String(id),
                 name: wireTarget.name,
                 directory: Path(url: directory),
@@ -174,7 +184,7 @@ internal struct PluginContextDeserializer {
                 artifactURL: artifact)
 
         case let .systemLibraryInfo(pkgConfig, compilerFlags, linkerFlags):
-            target = SystemLibraryTarget(
+            target = try SystemLibraryTarget(
                 id: String(id),
                 name: wireTarget.name,
                 directory: Path(url: directory),
@@ -261,7 +271,7 @@ internal struct PluginContextDeserializer {
             case .registry(let identity, let displayVersion):
                 .registry(identity: identity, displayVersion: displayVersion)
         }
-        let package = Package(
+        let package = try Package(
             id: wirePackage.identity,
             displayName: wirePackage.displayName,
             directory: Path(url: directory),

Sources/SPMBuildCore/Plugins/PluginContextSerializer.swift

@@ -43,7 +43,21 @@ internal struct PluginContextSerializer {
 
         // Split up the path into a base path and a subpath (currently always with the last path component as the
         // subpath, but this can be optimized where there are sequences of path components with a valence of one).
-        let basePathId = (path.parentDirectory.isRoot ? nil : try serialize(path: path.parentDirectory))
+        let basePathId: Int?
+        if path.parentDirectory.isRoot {
+            // Windows does not have a single root path like UNIX, so capture the root path itself such that we can rejoin it later
+            #if os(Windows)
+            let id = paths.count
+            paths.append(.init(baseURLId: nil, subpath: path.parentDirectory.pathString))
+            pathsToIds[path] = id
+            basePathId = id
+            #else
+            basePathId = nil
+            #endif
+        } else {
+            basePathId = try serialize(path: path.parentDirectory)
+        }
+
         let subpathString = path.basename
 
         // Finally assign the next wire ID to the path, and append a serialized Path record.

Sources/SPMBuildCore/Plugins/PluginInvocation.swift

@@ -272,24 +272,24 @@ extension PluginModule {
                     }
                     self.invocationDelegate.pluginDefinedBuildCommand(
                         displayName: config.displayName,
-                        executable: try AbsolutePath(validating: config.executable.path),
+                        executable: try config.executable.filePath,
                         arguments: config.arguments,
                         environment: config.environment,
-                        workingDirectory: try config.workingDirectory.map{ try AbsolutePath(validating: $0.path) },
-                        inputFiles: try inputFiles.map{ try AbsolutePath(validating: $0.path) },
-                        outputFiles: try outputFiles.map{ try AbsolutePath(validating: $0.path) })
+                        workingDirectory: try config.workingDirectory.map{ try $0.filePath },
+                        inputFiles: try inputFiles.map{ try $0.filePath },
+                        outputFiles: try outputFiles.map{ try $0.filePath })
 
                 case .definePrebuildCommand(let config, let outputFilesDir):
                     if config.version != 2 {
                         throw PluginEvaluationError.pluginUsesIncompatibleVersion(expected: 2, actual: config.version)
                     }
                     let success = self.invocationDelegate.pluginDefinedPrebuildCommand(
                         displayName: config.displayName,
-                        executable: try AbsolutePath(validating: config.executable.path),
+                        executable: try config.executable.filePath,
                         arguments: config.arguments,
                         environment: config.environment,
-                        workingDirectory: try config.workingDirectory.map{ try AbsolutePath(validating: $0.path) },
-                        outputFilesDirectory: try AbsolutePath(validating: outputFilesDir.path))
+                        workingDirectory: try config.workingDirectory.map{ try $0.filePath },
+                        outputFilesDirectory: try outputFilesDir.filePath)
 
                     if !success {
                         exitEarly = true