(#291) Debugger: use canonical paths for all files

Author: ForNeVeR

src/main/kotlin/com/intellij/plugin/powershell/ide/debugger/PowerShellDebugSession.kt

@@ -22,6 +22,7 @@ import org.eclipse.lsp4j.debug.*
 import org.eclipse.lsp4j.debug.services.IDebugProtocolServer
 import org.jetbrains.concurrency.await
 import java.nio.file.Path
+import kotlin.io.path.pathString
 
 class PowerShellDebugSession(
   client: PSDebugClient, val server: IDebugProtocolServer,
@@ -50,21 +51,23 @@ class PowerShellDebugSession(
   }
 
   fun setBreakpoint(filePath: Path, breakpoint: XLineBreakpoint<XBreakpointProperties<*>>) {
+    val path = filePath.toRealPath()
     coroutineScope.launch(start = CoroutineStart.UNDISPATCHED) {
       breakpointsMapMutex.withLock {
-        if (!breakpointMap.containsKey(filePath))
-          breakpointMap[filePath] = mutableMapOf()
-        val bpMap = breakpointMap[filePath]!!
+        if (!breakpointMap.containsKey(path))
+          breakpointMap[path] = mutableMapOf()
+        val bpMap = breakpointMap[path]!!
         bpMap[breakpoint.line] = breakpoint
         sendBreakpointRequest()
       }
     }
   }
 
   fun removeBreakpoint(filePath: Path, breakpoint: XLineBreakpoint<XBreakpointProperties<*>>) {
+    val path = filePath.toRealPath()
     coroutineScope.launch(start = CoroutineStart.UNDISPATCHED) {
       breakpointsMapMutex.withLock {
-        val bpMap = breakpointMap[filePath] ?: return@launch
+        val bpMap = breakpointMap[path] ?: return@launch
         if (!bpMap.containsKey(breakpoint.line))
           return@launch
         bpMap.remove(breakpoint.line)
@@ -124,35 +127,35 @@ class PowerShellDebugSession(
   }
 
   private suspend fun sendBreakpointRequest(breakpointMap: Map<Path, MutableMap<Int, XLineBreakpoint<XBreakpointProperties<*>>>>) {
-    for (breakpointMapEntry in breakpointMap) {
+    for ((file, breakpointsInFile) in breakpointMap) {
       val breakpointArgs = SetBreakpointsArguments()
       val source = Source()
-      source.path = breakpointMapEntry.key.toString()
+      source.path = file.pathString
       breakpointArgs.source = source
 
-      breakpointArgs.breakpoints = breakpointMapEntry.value.map {
-        val bp = it.value
+      breakpointArgs.breakpoints = breakpointsInFile.map {
+        val breakpoint = it.value
         SourceBreakpoint().apply {
-          line = bp.line + 1 // ide breakpoints line numbering starts from 0, while PSES start from 1
-          condition = bp.conditionExpression?.expression
-          logMessage = bp.logExpressionObject?.expression
+          line = breakpoint.line + 1 // ide breakpoints line numbering starts from 0, while PSES start from 1
+          condition = breakpoint.conditionExpression?.expression
+          logMessage = breakpoint.logExpressionObject?.expression
         }
       }.toTypedArray()
       try {
         val setBreakpointsResponse = server.setBreakpoints(breakpointArgs).await()
         val responseMap = setBreakpointsResponse.breakpoints.associateBy { x -> x.line - 1 }
-        breakpointMapEntry.value.forEach {
+        breakpointsInFile.forEach {
           val bp = responseMap[it.value.line]
           if (bp?.isVerified == true) {
             session.setBreakpointVerified(it.value)
-            logger.info("Set breakpoint at ${breakpointMapEntry.key}:${bp.line} successfully.")
+            logger.info("Set breakpoint at $file:${bp.line} successfully.")
           } else {
             session.setBreakpointInvalid(
               it.value,
               bp?.message.nullize(nullizeSpaces = true)
                 ?: MessagesBundle.message("powershell.debugger.breakpoints.invalidBreakPoint")
             )
-            logger.info("Invalid breakpoint at ${breakpointMapEntry.key}:${bp?.line}: ${bp?.message}")
+            logger.info("Invalid breakpoint at $file:${bp?.line}: ${bp?.message}")
           }
         }
       } catch (e: Throwable) {

src/main/kotlin/com/intellij/plugin/powershell/ide/run/PowerShellProgramDebugRunner.kt

@@ -16,7 +16,6 @@ import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.rd.util.toPromise
-import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.plugin.powershell.ide.MessagesBundle
 import com.intellij.plugin.powershell.ide.PluginProjectRoot
 import com.intellij.plugin.powershell.ide.debugger.EditorServicesDebuggerHostStarter
@@ -43,6 +42,7 @@ import org.jetbrains.concurrency.Promise
 import java.nio.file.Path
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.io.path.Path
+import kotlin.io.path.pathString
 
 class PowerShellProgramDebugRunner : AsyncProgramRunner<RunnerSettings>() {
 
@@ -158,15 +158,13 @@ private suspend fun initializeBreakpoints(
 ) {
   if (!debugSession.areBreakpointsMuted()) {
     breakpoints.filter { it.sourcePosition != null && it.sourcePosition!!.file.exists() && it.sourcePosition!!.file.isValid && it.isEnabled }
-      .groupBy { VfsUtil.virtualToIoFile(it.sourcePosition!!.file).toURI().toASCIIString() }
-      .forEach { entry ->
-        val fileURL = entry.key
+      .groupBy { it.sourcePosition!!.file.toNioPath().toRealPath() }
+      .forEach { (file, breakpoints) ->
         val breakpointArgs = SetBreakpointsArguments()
         val source = Source()
-        source.path = fileURL
+        source.path = file.pathString
         breakpointArgs.source = source
-        val bps = entry.value
-        breakpointArgs.breakpoints = bps.map {
+        breakpointArgs.breakpoints = breakpoints.map {
           val bp = it
           SourceBreakpoint().apply {
             line = bp.line + 1 // ide breakpoints line numbering starts from 0, while PSES start from 1
@@ -185,12 +183,13 @@ private suspend fun launchDebuggee(scriptPath: Path, remoteProxy: IDebugProtocol
 
   val launchArgs: MutableMap<String, Any> = HashMap()
   launchArgs["terminal"] = "none"
-  launchArgs["script"] = scriptPath.toString()
+  val scriptPathString = scriptPath.toRealPath().pathString
+  launchArgs["script"] = scriptPathString
   launchArgs["noDebug"] = false
   launchArgs["__sessionId"] = "sessionId"
   launchArgs["Args"] = runtimeArgs
   launchArgs["Env"] = envs
-  logger.info("Starting script file \"$scriptPath\" in a debug session.")
+  logger.info("Starting script file \"$scriptPathString\" in a debug session.")
   remoteProxy.launch(launchArgs).await()
 }
 

src/test/kotlin/com/intellij/plugin/powershell/debugger/BreakpointTest.kt

@@ -62,7 +62,7 @@ class BreakpointTest : DebuggerTestBase() {
         )
         val suspendContext = debugSession.suspendContext as PowerShellSuspendContext
         Assertions.assertEquals(
-          psiSecondFile.virtualFile.toNioPath(),
+          psiSecondFile.virtualFile.canonicalFile?.toNioPath(),
           suspendContext.activeExecutionStack.topFrame?.sourcePosition?.file?.toNioPath()
         )
         Assertions.assertEquals(line, suspendContext.activeExecutionStack.topFrame?.sourcePosition?.line)
@@ -71,8 +71,7 @@ class BreakpointTest : DebuggerTestBase() {
   }
 
   @Test
-  fun testConditionalBreakpoint()
-  {
+  fun testConditionalBreakpoint() {
     runInEdt {
       val psiFile = copyAndOpenFile("debugger/testBreakpoint.ps1")
       val file = psiFile.virtualFile