Standardize file paths when attempting to find toolchains

`containingXCToolchain` loops infinitely when given eg. `C:\foo\..\bar`.
The underlying cause is that `deletingLastPathComponent` does not remove
the `..` on Windows. On macOS it's potentially worse - it *adds* `..`.
We don't see the infinite loop on macOS/Linux though because
`AbsolutePath` already removes them (which is not the case on Windows).

Resolves #2174.

Author: bnbarham

Sources/SwiftExtensions/URLExtensions.swift

@@ -87,6 +87,8 @@ extension URL {
     }
   }
 
+  /// Assuming this URL is a file URL, checks if it looks like a root path. This is a string check, ie. the return
+  /// value for a path of `"/foo/.."` would be `false`. An error will be thrown is this is a non-file URL.
   package var isRoot: Bool {
     get throws {
       let checkPath = try filePath

Sources/ToolchainRegistry/Toolchain.swift

@@ -366,10 +366,20 @@ public final class Toolchain: Sendable {
 }
 
 /// Find a containing xctoolchain with plist, if available.
-func containingXCToolchain(
+private func containingXCToolchain(
   _ path: URL
 ) -> (XCToolchainPlist, URL)? {
-  var path = path
+  // `deletingLastPathComponent` only makes sense on resolved paths (ie. those without symlinks or `..`). Any given
+  // toolchain path should have already been realpathed, but since this can turn into an infinite loop otherwise, it's
+  // better to be safe than sorry.
+  guard let resolvedPath = try? path.realpath else {
+    return nil
+  }
+  if path != resolvedPath {
+    logger.fault("\(path) was not realpathed")
+  }
+
+  var path = resolvedPath
   while !((try? path.isRoot) ?? true) {
     if path.pathExtension == "xctoolchain" {
       if let infoPlist = orLog("Loading information from xctoolchain", { try XCToolchainPlist(fromDirectory: path) }) {

Sources/ToolchainRegistry/ToolchainRegistry.swift

@@ -96,6 +96,13 @@ package final actor ToolchainRegistry {
     var toolchainsByPath: [URL: Toolchain] = [:]
     var toolchainsByCompiler: [URL: Toolchain] = [:]
     for (toolchain, reason) in toolchainsAndReasonsParam {
+      // Toolchain should always be unique by path. It isn't particularly useful to log if we already have a toolchain
+      // though, as we could have just found toolchains through symlinks (this is actually quite normal - eg. OSS
+      // toolchains add a `swift-latest.xctoolchain` symlink on macOS).
+      if toolchainsByPath[toolchain.path] != nil {
+        continue
+      }
+
       // Non-XcodeDefault toolchain: disallow all duplicates.
       if toolchainsByIdentifier[toolchain.identifier] != nil,
         toolchain.identifier != ToolchainRegistry.darwinDefaultToolchainIdentifier
@@ -104,12 +111,6 @@ package final actor ToolchainRegistry {
         continue
       }
 
-      // Toolchain should always be unique by path.
-      if toolchainsByPath[toolchain.path] != nil {
-        logger.fault("Found two toolchains with the same path: \(toolchain.path)")
-        continue
-      }
-
       toolchainsByPath[toolchain.path] = toolchain
       toolchainsByIdentifier[toolchain.identifier, default: []].append(toolchain)
 
@@ -219,7 +220,9 @@ package final actor ToolchainRegistry {
     }
 
     let toolchainsAndReasons = toolchainPaths.compactMap {
-      if let toolchain = Toolchain($0.path) {
+      if let resolvedPath = try? $0.path.realpath,
+        let toolchain = Toolchain(resolvedPath)
+      {
         return (toolchain, $0.reason)
       }
       return nil
@@ -283,7 +286,18 @@ package final actor ToolchainRegistry {
   /// If we have a toolchain in the toolchain registry that contains the compiler with the given URL, return it.
   /// Otherwise, return `nil`.
   package func toolchain(withCompiler compiler: URL) -> Toolchain? {
-    return toolchainsByCompiler[compiler]
+    if let resolvedPath = try? compiler.realpath {
+      return toolchainsByCompiler[resolvedPath]
+    }
+    return nil
+  }
+
+  /// If we have a toolchain in the toolchain registry with the given URL, return it. Otherwise, return `nil`.
+  package func toolchain(withPath path: URL) -> Toolchain? {
+    if let resolvedPath = try? path.realpath {
+      return toolchainsByPath[resolvedPath]
+    }
+    return nil
   }
 }
 
@@ -292,10 +306,6 @@ extension ToolchainRegistry {
   package func toolchains(withIdentifier identifier: String) -> [Toolchain] {
     return toolchainsByIdentifier[identifier] ?? []
   }
-
-  package func toolchain(withPath path: URL) -> Toolchain? {
-    return toolchainsByPath[path]
-  }
 }
 
 extension ToolchainRegistry {

Tests/ToolchainRegistryTests/ToolchainRegistryTests.swift

@@ -336,7 +336,7 @@ final class ToolchainRegistryTests: XCTestCase {
 
       try ProcessEnv.setVar(
         "SOURCEKIT_PATH_FOR_TEST",
-        value: ["/bogus", binPath.filePath, "/bogus2"].joined(separator: separator)
+        value: ["/bogus/../parent", "/bogus", binPath.filePath, "/bogus2"].joined(separator: separator)
       )
       defer { try! ProcessEnv.setVar("SOURCEKIT_PATH_FOR_TEST", value: "") }