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

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

@@ -28,7 +28,6 @@ public class ScriptFile
         };
 
         private Version powerShellVersion;
-        private string _clientPath;
 
         #endregion
 
@@ -52,18 +51,18 @@ public string Id
         /// <summary>
         /// Gets the path which the editor client uses to identify this file.
         /// </summary>
-        public string ClientFilePath
-        {
-            get { return _clientPath; }
+        public string ClientFilePath { get; private set; }
 
-            private set
+        /// <summary>
+        /// Gets the file path in LSP DocumentUri form.  The ClientPath property must not be null.
+        /// </summary>
+        public string DocumentUri
+        {
+            get
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
-                _clientPath = GetPathAsClientPath(value);
+                return (this.ClientFilePath == null )
+                    ? string.Empty
+                    : Workspace.ConvertPathToDocumentUri(this.ClientFilePath);
             }
         }
 

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,59 @@ 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))
+            {
+                return new Uri(path).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 = System.Web.HttpUtility.UrlPathEncode(path);
+            int colonIndex = path.IndexOf(':');
+            for (var i = colonIndex - 1; i >= 0; i--)
+            {
+                newUri.Remove(i, 1);
+                newUri.Insert(i, char.ToLowerInvariant(path[i]).ToString());
+            }
+
+            // On a Linux filesystem, you can have multiple colons in a filename e.g. foo:bar:baz.txt
+            if (colonIndex >= 0)
+            {
+                newUri = newUri.Replace(":", "%3A");
+            }
+
+            return newUri
+                .Replace('\\', '/')
+                .Insert(0, fileUriPrefix)
+                .ToString();
+        }
+
         #endregion
     }
 }