IJPL-213371: support resolve for symlinks that point to files with special chars on WSL.

See: `com.intellij.platform.ijent.functional.IjentSpecialCharsTest.testCharInSymLink`


Merge-request: IJ-MR-214143
Merged-by: Ilya Kazakevich <ilya.kazakevich@jetbrains.com>

GitOrigin-RevId: 3d51da52581b5b8abbd9357e2151a2a52570df2d

Author: throwable-one

platform/eel/src/com/intellij/platform/eel/path/EelPath.kt

@@ -19,6 +19,10 @@ val EelPath.platform: EelOsFamily get() = descriptor.osFamily
  * All operations listed here do not require I/O.
  *
  * In the examples below, `descriptor` is a POSIX [EelDescriptor] and `windowsDescriptor` is a Windows one.
+ *
+ * [EelPath] contains both: [EelDescriptor] and a path on it (e.g. a descriptor of a Docker container and path `/root` inside of it).
+ * To get the path on [EelDescriptor] (to pass it to a remote command for example), use [toString];
+ * [fileName] returns only the last component of it.
  */
 @ApiStatus.Experimental
 sealed interface EelPath {

platform/platform-impl/eel/src/com/intellij/platform/ide/impl/wsl/ijent/nio/IjentWslNioFileSystemProvider.kt

@@ -4,9 +4,11 @@ package com.intellij.platform.ide.impl.wsl.ijent.nio
 import com.intellij.execution.wsl.WslPath
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.util.NlsSafe
+import com.intellij.platform.core.nio.fs.MultiRoutingFsPath
 import com.intellij.platform.core.nio.fs.RoutingAwareFileSystemProvider
 import com.intellij.platform.eel.EelDescriptor
 import com.intellij.platform.eel.provider.utils.EelPathTransfer
+import com.intellij.platform.eel.provider.utils.impl.ijentToLocal
 import com.intellij.platform.eel.provider.utils.impl.localToIjent
 import com.intellij.platform.ide.impl.wsl.WSL_PREFIXES
 import com.intellij.platform.ijent.community.impl.nio.IjentNioPath
@@ -93,7 +95,10 @@ internal class IjentWslNioFileSystemProvider(
     val notationLowerCase = notation.lowercase()
     assert(notationLowerCase in WSL_PREFIXES) { notation }
     return when (this) {
-      is IjentNioPath -> fold(originalFs.getPath("\\\\$notation\\$wslId\\")) { parent, file -> parent.resolve(file.toString()) }
+      // `ijentToLocal` is mandatory: chars like `:` are legal in Linux file names, but `WindowsPath` can't hold them as is.
+      is IjentNioPath -> fold(originalFs.getPath("\\\\$notation\\$wslId\\")) { parent, file ->
+        parent.resolve(ijentToLocal(file.toString()))
+      }
       is IjentWslNioPath -> presentablePath.toOriginalPath(notation)
       else -> this
     }
@@ -103,6 +108,8 @@ internal class IjentWslNioFileSystemProvider(
     return when (this) {
       is IjentNioPath -> error(this)
       is IjentWslNioPath -> presentablePath.toOriginalPathWithSameNotation()
+      // The original file system provider throws ProviderMismatchException for paths of the routing file system.
+      is MultiRoutingFsPath -> initialDelegate.toOriginalPathWithSameNotation()
       else -> this
     }
   }
@@ -132,14 +139,25 @@ internal class IjentWslNioFileSystemProvider(
     }
   }
 
-  private fun wslIdFromPath(path: Path): String? {
-    val root = path.toAbsolutePath().root.toString()
+  private fun wslIdFromPath(path: Path): String? = wslIdFromRoot(path.toAbsolutePath().root.toString())
+
+  private fun wslIdFromRoot(root: String): String? {
     val wslMarker = """\\wsl"""
     if (!root.startsWith(wslMarker, ignoreCase = true)) return null
     val wslId = root.substring(wslMarker.length).substringAfter('\\').trimEnd('\\')
     return wslId.ifEmpty { null }
   }
 
+  /**
+   * `wsl$` or `wsl.localhost`, taken from [root] which looks like `\\wsl$\distro\`.
+   * A relative path has no root to take the notation from, so an empty [root] is accepted and yields the fallback.
+   */
+  internal fun notationFromRoot(root: String): String {
+    val notation = root.removePrefix("""\\""").substringBefore('\\')
+    // `wsl.localhost` is the notation supported by all WSL versions, hence it is the fallback.
+    return if (WSL_NOTATIONS.any { it.equals(notation, ignoreCase = true) }) notation else WSL_NOTATIONS[0]
+  }
+
   override fun checkAccess(path: Path, vararg modes: AccessMode): Unit = ijentFsProvider.checkAccess(path.toIjentPath(), *modes)
 
   override fun newInputStream(path: Path, vararg options: OpenOption?): InputStream =
@@ -171,12 +189,24 @@ internal class IjentWslNioFileSystemProvider(
 
   override fun deleteIfExists(path: Path): Boolean = ijentFsProvider.deleteIfExists(path.toIjentPath())
 
-  override fun readSymbolicLink(link: Path): IjentWslNioPath = IjentWslNioPath(
-    getFileSystem(wslIdFromPath(link)
-                  ?: throw IOException("Cannot find WSL distribution for $link. The URL is incorrect or the distribution does not exist.")),
-    ijentFsProvider.readSymbolicLink(link.toIjentPath()),
-    null,
-  )
+  override fun readSymbolicLink(link: Path): IjentWslNioPath {
+    val root = link.toAbsolutePath().root.toString()
+    val wslId = wslIdFromRoot(root)
+                ?: throw IOException("Cannot find WSL distribution for $link. The URL is incorrect or the distribution does not exist.")
+    val target = ijentFsProvider.readSymbolicLink(link.toIjentPath())
+    // The link target is what the user and the tools see, so it must be a Windows path even though IJent reports a Linux one:
+    // otherwise `link.parent.resolve(target)` and `target.toString()` produce garbage for targets with chars like `:` in them.
+    val presentableTarget =
+      if (target.isAbsolute) {
+        // The notation is taken from `link` because `\\wsl$\` and `\\wsl.localhost\` must never be mixed within one path.
+        target.toOriginalPath(notationFromRoot(root))
+      }
+      else {
+        // A relative target has no root, hence no notation; only the special chars have to be mapped.
+        originalFs.getPath(ijentToLocal(target.toString()))
+      }
+    return IjentWslNioPath(getFileSystem(wslId), presentableTarget, null)
+  }
 
   override fun getPath(uri: URI): Path = IjentWslNioPath(
     getFileSystem(wslIdFromPath(originalFsProvider.getPath(uri))
@@ -317,5 +347,11 @@ internal class IjentWslNioFileSystemProvider(
 
   companion object {
     private val LOG = logger<IjentWslNioFileSystemProvider>()
+
+    /**
+     * The two interchangeable notations of a WSL UNC root.
+     * They must never be mixed within one path, see [com.intellij.platform.eel.provider.asNioPath].
+     */
+    internal val WSL_NOTATIONS: List<String> = listOf("wsl.localhost", "wsl$")
   }
 }

platform/platform-impl/eel/src/com/intellij/platform/ide/impl/wsl/ijent/nio/IjentWslNioPath.kt

@@ -2,15 +2,20 @@
 package com.intellij.platform.ide.impl.wsl.ijent.nio
 
 import com.intellij.platform.core.nio.fs.BasicFileAttributesHolder2
+import com.intellij.platform.core.nio.fs.MultiRoutingFsPath
 import com.intellij.platform.eel.provider.utils.EelPathUtils.getActualPath
+import com.intellij.platform.eel.provider.utils.impl.ijentToLocal
+import com.intellij.platform.eel.provider.utils.impl.localToIjent
 import com.intellij.platform.ide.impl.wsl.WSL_PREFIXES
+import com.intellij.platform.ijent.community.impl.nio.IjentNioPath
 import com.intellij.platform.ijent.community.impl.nio.fs.IjentNioPosixFileAttributesWithDosAdapter
 import java.net.URI
 import java.nio.file.LinkOption
 import java.nio.file.Path
 import java.nio.file.WatchEvent
 import java.nio.file.WatchKey
 import java.nio.file.WatchService
+import kotlin.io.path.pathString
 
 internal class IjentWslNioPath(
   private val fileSystem: IjentWslNioFileSystem,
@@ -23,7 +28,12 @@ internal class IjentWslNioPath(
   cachedAttributes: IjentNioPosixFileAttributesWithDosAdapter?,
 ) : Path, BasicFileAttributesHolder2.Impl(cachedAttributes) {
   init {
-    require(presentablePath !is IjentWslNioPath) { "IjentWslNioPath should be a wrapper over other instances of path, namely WindowsPath or IjentNioPath" }
+    // `MultiRoutingFsPath` is rejected as well: it may delegate to an `IjentWslNioPath`, and such nesting silently breaks
+    // `equals`, `hashCode` and every call that passes `presentablePath` to the original (Windows) file system provider.
+    require(presentablePath !is IjentWslNioPath && presentablePath !is MultiRoutingFsPath) {
+      "IjentWslNioPath should be a wrapper over other instances of path, namely WindowsPath or IjentNioPath," +
+      " but got ${presentablePath.javaClass.name}: $presentablePath"
+    }
   }
 
   val actualPath: Path = getActualPath(presentablePath)
@@ -50,13 +60,18 @@ internal class IjentWslNioPath(
 
   override fun normalize(): IjentWslNioPath = presentablePath.normalize().toIjentWslPath()
 
-  override fun resolve(other: Path): IjentWslNioPath = presentablePath.resolve(other.toOriginalPath()).toIjentWslPath()
+  override fun resolve(other: Path): IjentWslNioPath {
+    val otherPath = other.toSameFlavourAsPresentablePath()
+    // `Path.resolve` returns `other` as is when it is absolute, but the result still has to be a path of this file system.
+    return if (otherPath.isAbsolute) otherPath.toIjentWslPath()
+    else presentablePath.resolve(otherPath).toIjentWslPath()
+  }
 
   override fun relativize(other: Path): IjentWslNioPath {
     if (isAbsolute != other.isAbsolute) {
       throw IllegalArgumentException("Tried to relativize a relative and an absolute path: `$this` and `$other`." + " Check for possible confusion." + " Maybe some code up the call stack tried to use a path from the Linux machine as a WSL path for Windows.")
     }
-    return presentablePath.relativize(other.toOriginalPath()).toIjentWslPath()
+    return presentablePath.relativize(other.toSameFlavourAsPresentablePath()).toIjentWslPath()
   }
 
   override fun toUri(): URI = presentablePath.toUri()
@@ -83,10 +98,7 @@ internal class IjentWslNioPath(
     else {
       ijentNioPath.toRealPath(*options)
     }
-    val originalPath = fileSystem.provider().toOriginalPath(
-      path = ijentNioRealPath,
-      notation = root.toString().removePrefix("\\\\").substringBefore('\\'),
-    )
+    val originalPath = fileSystem.provider().toOriginalPath(path = ijentNioRealPath, notation = presentableNotation)
     return originalPath.toIjentWslPath()
   }
 
@@ -97,10 +109,49 @@ internal class IjentWslNioPath(
 
   override fun compareTo(other: Path): Int = presentablePath.compareTo(other.toOriginalPath())
 
-  private fun Path.toIjentWslPath(): IjentWslNioPath = IjentWslNioPath(this@IjentWslNioPath.fileSystem, this, null)
+  private fun Path.toIjentWslPath(): IjentWslNioPath =
+    this as? IjentWslNioPath ?: IjentWslNioPath(this@IjentWslNioPath.fileSystem, this, null)
+
+  private fun Path.toOriginalPath(): Path = when (this) {
+    is IjentWslNioPath -> this.presentablePath.toOriginalPath()
+    // A path of the routing file system may delegate to a path of this very file system, so it is not a foreign path.
+    is MultiRoutingFsPath -> this.initialDelegate.toOriginalPath()
+    else -> this
+  }
 
-  private fun Path.toOriginalPath(): Path = if (this is IjentWslNioPath) this.presentablePath
-  else this
+  /**
+   * Returns [this] converted to the same kind of path as [presentablePath] (i.e. `WindowsPath` or [IjentNioPath]),
+   * so that both can be used together in a single [Path] operation.
+   * Special chars like `:` are mapped in the direction that [presentablePath] requires, see [ijentToLocal] and [localToIjent].
+   *
+   * This is the same trick as [MultiRoutingFsPath.toSameTypeAsDelegate]:
+   * it is always the *argument* that is brought to the flavour of the receiver, never the other way round.
+   */
+  private fun Path.toSameFlavourAsPresentablePath(): Path {
+    val originalPath = toOriginalPath()
+    return when {
+      presentablePath.javaClass == originalPath.javaClass -> originalPath
+      // An absolute IJent path has no `\\wsl$\distro\` prefix, and that prefix must use the same notation as this path.
+      originalPath is IjentNioPath && originalPath.isAbsolute ->
+        this@IjentWslNioPath.fileSystem.provider().toOriginalPath(originalPath, presentableNotation)
+
+      originalPath is IjentNioPath ->
+        presentablePath.fileSystem.getPath(ijentToLocal(originalPath.pathString))
+
+      presentablePath is IjentNioPath ->
+        presentablePath.fileSystem.getPath(localToIjent(originalPath.pathString.replace('\\', '/')))
+
+      else ->
+        presentablePath.fileSystem.getPath(originalPath.pathString)
+    }
+  }
+
+  /**
+   * `wsl$` or `wsl.localhost`: the notation used by this path.
+   * These two must never be mixed within one path, see [com.intellij.platform.eel.provider.asNioPath].
+   */
+  private val presentableNotation: String
+    get() = fileSystem.provider().notationFromRoot(presentablePath.root?.toString() ?: "")
 
   override fun toString(): String = presentablePath.toString()