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.ClientPathAsDocumentUri,
                         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
 {
@@ -54,7 +52,7 @@ private CodeLens[] GetPesterLens(
                     new ClientCommand(
                         "PowerShell.RunPesterTests",
                         "Run tests",
-                        new object[] { scriptFile.ClientFilePath, false /* No debug */, pesterSymbol.TestName })),
+                        new object[] { scriptFile.ClientPathAsDocumentUri, false /* No debug */, pesterSymbol.TestName })),
 
                 new CodeLens(
                     this,
@@ -63,7 +61,7 @@ private CodeLens[] GetPesterLens(
                     new ClientCommand(
                         "PowerShell.RunPesterTests",
                         "Debug tests",
-                        new object[] { scriptFile.ClientFilePath, true /* Run in debugger */, pesterSymbol.TestName })),
+                        new object[] { scriptFile.ClientPathAsDocumentUri, true /* Run in debugger */, pesterSymbol.TestName })),
             };
 
             return codeLensResults;

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.ClientPathAsDocumentUri,
                         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.ClientPathAsDocumentUri] = 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.ClientPathAsDocumentUri,
                     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,16 @@ 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 ClientPath in LSP DocumentUri form.  The ClientPath property must not be null.
+        /// </summary>
+        public string ClientPathAsDocumentUri
+        {
+            get 
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-
-                _clientPath = GetPathAsClientPath(value);
+                return Workspace.ConvertPathToDocumentUri(this.ClientFilePath);
             }
         }
 

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -624,6 +624,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
     }
 }