Fix #287: Handle invalid path chars when resolving script references

This change resolves an issue that appears when the user edits a script
that has dot-sourced script references which contain invalid characters.
The fix handles the exceptions that might be thrown in this case and
writes out the path details to the log file.

Related to PowerShell/vscode-powershell#274.

Author: daviwil

src/PowerShellEditorServices/Language/FindDotSourcedVisitor.cs

@@ -34,9 +34,11 @@ public override AstVisitAction VisitCommand(CommandAst commandAst)
         {
             if (commandAst.InvocationOperator.Equals(TokenKind.Dot))
             {
-                string fileName = commandAst.CommandElements[0].Extent.Text;
+                // Strip any quote characters off of the string
+                string fileName = commandAst.CommandElements[0].Extent.Text.Trim('\'', '"');
                 DotSourcedFiles.Add(fileName);
             }
+
             return base.VisitCommand(commandAst);
         }
     }

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -203,6 +203,12 @@ private void RecursivelyFindReferences(
                         baseFilePath,
                         referencedFileName);
 
+                // If there was an error resolving the string, skip this reference
+                if (resolvedScriptPath == null)
+                {
+                    continue;
+                }
+
                 Logger.Write(
                     LogLevel.Verbose,
                     string.Format(
@@ -287,18 +293,49 @@ private string GetBaseFilePath(string filePath)
 
         private string ResolveRelativeScriptPath(string baseFilePath, string relativePath)
         {
-            if (Path.IsPathRooted(relativePath))
+            string combinedPath = null;
+            Exception resolveException = null;
+
+            try
             {
-                return relativePath;
+                // If the path is already absolute there's no need to resolve it relatively
+                // to the baseFilePath.
+                if (Path.IsPathRooted(relativePath))
+                {
+                    return relativePath;
+                }
+
+                // Get the directory of the original script file, combine it
+                // with the given path and then resolve the absolute file path.
+                combinedPath =
+                    Path.GetFullPath(
+                        Path.Combine(
+                            baseFilePath,
+                            relativePath));
+            }
+            catch (NotSupportedException e)
+            {
+                // Occurs if the path is incorrectly formatted for any reason.  One
+                // instance where this occurred is when a user had curly double-quote
+                // characters in their source instead of normal double-quotes.
+                resolveException = e;
+            }
+            catch (ArgumentException e)
+            {
+                // Occurs if the path contains invalid characters, specifically those
+                // listed in System.IO.Path.InvalidPathChars.
+                resolveException = e;
             }
 
-            // Get the directory of the original script file, combine it
-            // with the given path and then resolve the absolute file path.
-            string combinedPath =
-                Path.GetFullPath(
-                    Path.Combine(
-                        baseFilePath,
-                        relativePath));
+            if (resolveException != null)
+            {
+                Logger.Write(
+                    LogLevel.Error,
+                    $"Could not resolve relative script path\r\n" +
+                    $"    baseFilePath = {baseFilePath}\r\n    " +
+                    $"    relativePath = {relativePath}\r\n\r\n" +
+                    $"{resolveException.ToString()}");
+            }
 
             return combinedPath;
         }