Fix unable to open files in problems/peek windows issue (#872)

* Fix unable to open files in problems/peek windows issue

This is due to PSES not properly storing a language client path in the
ClientFilePath property of ScriptFile.  This change ensures that a
ClientFilePath is always stored in the text document Uri that a LSP
client expects.  This code has mostly been provided by
@SeeminglyScience. Thanks for the reference to your code.
This fixes issue 1732 in the vscode-powershell repo.

* Play it safe by adding a new property instead of changing ClientPath

* Address Codacy issues

* Add tests for DocumentUri and fix colon issue on Linux/macOS

* Attempt to fix where we replace colons on Linux

* Try to fix tests for Linux

* Address PR feedback

* Kick the build

* Address PR feedback, use StringBuilder.Replace()

* Add test for backslash char on Linux/macOS.

* Update src/PowerShellEditorServices/Workspace/Workspace.cs

Co-Authored-By: rkeithhill <r_keith_hill@hotmail.com>

Author: rkeithhill

src/PowerShellEditorServices.Host/CodeLens/CodeLensFeature.cs

@@ -126,7 +126,7 @@ private async Task HandleCodeLensRequestAsync(
                 codeLensResponse[i] = codeLensResults[i].ToProtocolCodeLens(
                     new CodeLensData
                     {
-                        Uri = codeLensResults[i].File.ClientFilePath,
+                        Uri = codeLensResults[i].File.DocumentUri,
                         ProviderId = codeLensResults[i].Provider.ProviderId
                     },
                     _jsonSerializer);

src/PowerShellEditorServices.Host/CodeLens/PesterCodeLensProvider.cs

@@ -3,13 +3,11 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using Microsoft.PowerShell.EditorServices.Commands;
-using Microsoft.PowerShell.EditorServices.Symbols;
-using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.PowerShell.EditorServices.Commands;
+using Microsoft.PowerShell.EditorServices.Symbols;
 
 namespace Microsoft.PowerShell.EditorServices.CodeLenses
 {
@@ -53,7 +51,7 @@ private CodeLens[] GetPesterLens(PesterSymbolReference pesterSymbol, ScriptFile
                         "PowerShell.RunPesterTests",
                         "Run tests",
                         new object[] {
-                            scriptFile.ClientFilePath,
+                            scriptFile.DocumentUri,
                             false /* No debug */,
                             pesterSymbol.TestName,
                             pesterSymbol.ScriptRegion?.StartLineNumber })),
@@ -66,7 +64,7 @@ private CodeLens[] GetPesterLens(PesterSymbolReference pesterSymbol, ScriptFile
                         "PowerShell.RunPesterTests",
                         "Debug tests",
                         new object[] {
-                            scriptFile.ClientFilePath,
+                            scriptFile.DocumentUri,
                             true /* Run in the debugger */,
                             pesterSymbol.TestName,
                             pesterSymbol.ScriptRegion?.StartLineNumber })),

src/PowerShellEditorServices.Host/CodeLens/ReferencesCodeLensProvider.cs

@@ -118,7 +118,7 @@ public async Task<CodeLens> ResolveCodeLensAsync(
                     GetReferenceCountHeader(referenceLocations.Length),
                     new object[]
                     {
-                        codeLens.File.ClientFilePath,
+                        codeLens.File.DocumentUri,
                         codeLens.ScriptExtent.ToRange().Start,
                         referenceLocations,
                     }

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -1757,15 +1757,15 @@ private static async Task PublishScriptDiagnosticsAsync(
                 diagnostics.Add(markerDiagnostic);
             }
 
-            correctionIndex[scriptFile.ClientFilePath] = fileCorrections;
+            correctionIndex[scriptFile.DocumentUri] = fileCorrections;
 
             // Always send syntax and semantic errors.  We want to
             // make sure no out-of-date markers are being displayed.
             await eventSender(
                 PublishDiagnosticsNotification.Type,
                 new PublishDiagnosticsNotification
                 {
-                    Uri = scriptFile.ClientFilePath,
+                    Uri = scriptFile.DocumentUri,
                     Diagnostics = diagnostics.ToArray()
                 });
         }

src/PowerShellEditorServices/Workspace/ScriptFile.cs

@@ -3,13 +3,14 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
+using System.Runtime.InteropServices;
+using Microsoft.PowerShell.EditorServices.Utility;
 
 namespace Microsoft.PowerShell.EditorServices
 {
@@ -52,6 +53,19 @@ public string Id
         /// </summary>
         public string ClientFilePath { get; private set; }
 
+        /// <summary>
+        /// Gets the file path in LSP DocumentUri form.  The ClientPath property must not be null.
+        /// </summary>
+        public string DocumentUri
+        {
+            get
+            {
+                return this.ClientFilePath == null
+                    ? string.Empty
+                    : Workspace.ConvertPathToDocumentUri(this.ClientFilePath);
+            }
+        }
+
         /// <summary>
         /// Gets or sets a boolean that determines whether
         /// semantic analysis should be enabled for this file.

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -351,7 +351,7 @@ private void RecursivelyEnumerateFiles(string folderPath, ref List<string> found
                     this.logger.WriteHandledException(
                         $"Could not enumerate files in the path '{folderPath}' due to an exception",
                         e);
-                    
+
                     continue;
                 }
 
@@ -400,7 +400,7 @@ private void RecursivelyEnumerateFiles(string folderPath, ref List<string> found
                 this.logger.WriteHandledException(
                     $"Could not enumerate directories in the path '{folderPath}' due to an exception",
                     e);
-                
+
                 return;
             }
 
@@ -625,6 +625,69 @@ private static string UnescapeDriveColon(string fileUri)
             return sb.ToString();
         }
 
+        /// <summary>
+        /// Converts a file system path into a DocumentUri required by Language Server Protocol.
+        /// </summary>
+        /// <remarks>
+        /// When sending a document path to a LSP client, the path must be provided as a
+        /// DocumentUri in order to features like the Problems window or peek definition
+        /// to be able to open the specified file.
+        /// </remarks>
+        /// <param name="path">
+        /// A file system path. Note: if the path is already a DocumentUri, it will be returned unmodified.
+        /// </param>
+        /// <returns>The file system path encoded as a DocumentUri.</returns>
+        internal static string ConvertPathToDocumentUri(string path)
+        {
+            const string fileUriPrefix = "file:///";
+
+            if (path.StartsWith("untitled:", StringComparison.Ordinal))
+            {
+                return path;
+            }
+
+            if (path.StartsWith(fileUriPrefix, StringComparison.Ordinal))
+            {
+                return path;
+            }
+
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                // On a Linux filesystem, you can have multiple colons in a filename e.g. foo:bar:baz.txt
+                string absoluteUri = new Uri(path).AbsoluteUri;
+
+                // First colon is part of the protocol scheme, see if there are other colons in the path
+                int firstColonIndex = absoluteUri.IndexOf(':');
+                if (absoluteUri.IndexOf(':', firstColonIndex + 1) > firstColonIndex)
+                {
+                    absoluteUri = new StringBuilder(absoluteUri)
+                        .Replace(
+                            oldValue: ":",
+                            newValue: "%3A",
+                            startIndex: firstColonIndex + 1,
+                            count: absoluteUri.Length - firstColonIndex - 1)
+                        .ToString();
+                }
+
+                return absoluteUri;
+            }
+
+            // VSCode file URIs on Windows need the drive letter lowercase, and the colon
+            // URI encoded. System.Uri won't do that, so we manually create the URI.
+            var newUri = new StringBuilder(System.Web.HttpUtility.UrlPathEncode(path));
+            int colonIndex = path.IndexOf(':');
+            if (colonIndex > 0)
+            {
+                int driveLetterIndex = colonIndex - 1;
+                char driveLetter = char.ToLowerInvariant(path[driveLetterIndex]);
+                newUri
+                    .Replace(path[driveLetterIndex], driveLetter, driveLetterIndex, 1)
+                    .Replace(":", "%3A", colonIndex, 1);
+            }
+
+            return newUri.Replace('\\', '/').Insert(0, fileUriPrefix).ToString();
+        }
+
         #endregion
     }
 }

test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs

@@ -101,7 +101,7 @@ public static IEnumerable<object[]> DebuggerAcceptsScriptArgsTestData
         }
 
         [Theory]
-        [MemberData("DebuggerAcceptsScriptArgsTestData")]
+        [MemberData(nameof(DebuggerAcceptsScriptArgsTestData))]
         public async Task DebuggerAcceptsScriptArgs(string[] args)
         {
             // The path is intentionally odd (some escaped chars but not all) because we are testing

test/PowerShellEditorServices.Test/Session/ScriptFileTests.cs

@@ -572,6 +572,7 @@ public void PropertiesInitializedCorrectlyForUntitled()
 
                 Assert.Equal(path, scriptFile.FilePath);
                 Assert.Equal(path, scriptFile.ClientFilePath);
+                Assert.Equal(path, scriptFile.DocumentUri);
                 Assert.True(scriptFile.IsAnalysisEnabled);
                 Assert.True(scriptFile.IsInMemory);
                 Assert.Empty(scriptFile.ReferencedFiles);
@@ -580,5 +581,35 @@ public void PropertiesInitializedCorrectlyForUntitled()
                 Assert.Equal(3, scriptFile.FileLines.Count);
             }
         }
+
+        [Fact]
+        public void DocumentUriRetunsCorrectStringForAbsolutePath()
+        {
+            string path;
+            ScriptFile scriptFile;
+            var emptyStringReader = new StringReader("");
+
+            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
+            {
+                path = @"C:\Users\AmosBurton\projects\Rocinate\ProtoMolecule.ps1";
+                scriptFile = new ScriptFile(path, path, emptyStringReader, PowerShellVersion);
+                Assert.Equal("file:///c%3A/Users/AmosBurton/projects/Rocinate/ProtoMolecule.ps1", scriptFile.DocumentUri);
+            }
+            else
+            {
+                // Test the following only on Linux and macOS.
+                path = "/home/AlexKamal/projects/Rocinate/ProtoMolecule.ps1";
+                scriptFile = new ScriptFile(path, path, emptyStringReader, PowerShellVersion);
+                Assert.Equal("file:///home/AlexKamal/projects/Rocinate/ProtoMolecule.ps1", scriptFile.DocumentUri);
+
+                path = "/home/NaomiNagata/projects/Rocinate/Proto:Mole:cule.ps1";
+                scriptFile = new ScriptFile(path, path, emptyStringReader, PowerShellVersion);
+                Assert.Equal("file:///home/NaomiNagata/projects/Rocinate/Proto%3AMole%3Acule.ps1", scriptFile.DocumentUri);
+
+                path = "/home/JamesHolden/projects/Rocinate/Proto:Mole\\cule.ps1";
+                scriptFile = new ScriptFile(path, path, emptyStringReader, PowerShellVersion);
+                Assert.Equal("file:///home/JamesHolden/projects/Rocinate/Proto%3AMole%5Ccule.ps1", scriptFile.DocumentUri);
+            }
+        }
     }
 }