PackageModel/Toolset: fix support for relative rootPath (#6195)

Currently `DecodedToolset` only decodes `AbsolutePath` directly, while it should be able to support relative paths as well. Let's fix that by decoding to `String` first and then resolving to `AbsolutePath` when creating a `Toolset` value from `DecodedToolset`. Also added a corresponding test assertion that verifies that applied fix works.

Author: MaxDesiatov

Sources/PackageModel/Toolset.swift

@@ -76,6 +76,10 @@ extension Toolset {
             )
         }
 
+        let rootPaths = try decoded.rootPath.map {
+            [try AbsolutePath(validating: $0, relativeTo: toolsetPath.parentDirectory)]
+        } ?? []
+
         var knownTools = [KnownTool: ToolProperties]()
         var hasEmptyToolConfiguration = false
         for (tool, properties) in decoded.tools {
@@ -89,7 +93,7 @@ extension Toolset {
                 if let absolutePath = try? AbsolutePath(validating: path) {
                     toolPath = absolutePath
                 } else {
-                    let rootPath = decoded.rootPath ?? toolsetPath.parentDirectory
+                    let rootPath = rootPaths.first ?? toolsetPath.parentDirectory
                     toolPath = rootPath.appending(RelativePath(path))
                 }
             } else {
@@ -119,13 +123,6 @@ extension Toolset {
             throw StringError("Toolset configuration at `\(toolsetPath)` has at least one tool with no properties.")
         }
 
-        let rootPaths: [AbsolutePath]
-        if let rootPath = decoded.rootPath {
-            rootPaths = [rootPath]
-        } else {
-            rootPaths = []
-        }
-
         self.init(knownTools: knownTools, rootPaths: rootPaths)
     }
 
@@ -174,7 +171,7 @@ private struct DecodedToolset {
 
     /// Root path of the toolset, if present. When filling in ``Toolset.ToolProperties/path``, if a raw path string in
     /// ``DecodedToolset`` is inferred to be relative, it's resolved as absolute path relatively to `rootPath`.
-    let rootPath: AbsolutePath?
+    let rootPath: String?
 
     /// Dictionary of raw tools that haven't been validated yet to match ``Toolset.KnownTool``.
     var tools: [String: ToolProperties]
@@ -206,7 +203,7 @@ extension DecodedToolset: Decodable {
             versionString: container.decode(String.self, forKey: .schemaVersion),
             usesLenientParsing: true
         )
-        self.rootPath = try container.decodeIfPresent(AbsolutePath.self, forKey: .rootPath)
+        self.rootPath = try container.decodeIfPresent(String.self, forKey: .rootPath)
 
         self.tools = [String: DecodedToolset.ToolProperties]()
         for key in container.allKeys {

Tests/PackageModelTests/ToolsetTests.swift

@@ -85,11 +85,22 @@ private let someToolsWithRoot = (
     """#
 )
 
+private let someToolsWithRelativeRoot = (
+    path: try! AbsolutePath(validating: "/tools/someToolsWithRelativeRoot.json"),
+    json: #"""
+    {
+        "schemaVersion": "1.0",
+        "rootPath": "relative/custom",
+        "cCompiler": { "extraCLIOptions": \#(newCCompilerOptions) }
+    }
+    """#
+)
+
 final class ToolsetTests: XCTestCase {
     func testToolset() throws {
         let fileSystem = InMemoryFileSystem()
         try fileSystem.createDirectory(.init(validating: "/tools"))
-        for testFile in [compilersNoRoot, noValidToolsNoRoot, unknownToolsNoRoot, otherToolsNoRoot, someToolsWithRoot] {
+        for testFile in [compilersNoRoot, noValidToolsNoRoot, unknownToolsNoRoot, otherToolsNoRoot, someToolsWithRoot, someToolsWithRelativeRoot] {
             try fileSystem.writeFileContents(testFile.path, data: .init(testFile.json.utf8))
         }
         let observability = ObservabilitySystem.makeForTesting()
@@ -190,5 +201,14 @@ final class ToolsetTests: XCTestCase {
             otherToolsToolset.knownTools[.debugger],
             Toolset.ToolProperties(path: usrBinTools[.debugger]!)
         )
+
+        let someToolsWithRelativeRoot = try Toolset(from: someToolsWithRelativeRoot.path, at: fileSystem, observability.topScope)
+        XCTAssertEqual(
+            someToolsWithRelativeRoot,
+            Toolset(
+                knownTools: [.cCompiler: .init(extraCLIOptions: newCCompilerOptions)],
+                rootPaths: [try AbsolutePath(validating: "/tools/relative/custom")]
+            )
+        )
     }
 }