Merge pull request #436 from PowerShell/kapilmb/workspace-wide-reference

Enable reference look up in entire workspace

Author: daviwil

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -679,7 +679,8 @@ protected async Task HandleReferencesRequest(
             FindReferencesResult referencesResult =
                 await editorSession.LanguageService.FindReferencesOfSymbol(
                     foundSymbol,
-                    editorSession.Workspace.ExpandScriptReferences(scriptFile));
+                    editorSession.Workspace.ExpandScriptReferences(scriptFile),
+                    editorSession.Workspace);
 
             Location[] referenceLocations = null;
 

src/PowerShellEditorServices/Language/LanguageService.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
@@ -248,10 +249,12 @@ public FindOccurrencesResult FindSymbolsInFile(ScriptFile scriptFile)
         /// </summary>
         /// <param name="foundSymbol">The symbol to find all references for</param>
         /// <param name="referencedFiles">An array of scriptFiles too search for references in</param>
+        /// <param name="workspace">The workspace that will be searched for symbols</param>
         /// <returns>FindReferencesResult</returns>
         public async Task<FindReferencesResult> FindReferencesOfSymbol(
             SymbolReference foundSymbol,
-            ScriptFile[] referencedFiles)
+            ScriptFile[] referencedFiles,
+            Workspace workspace)
         {
             if (foundSymbol != null)
             {
@@ -262,9 +265,26 @@ public async Task<FindReferencesResult> FindReferencesOfSymbol(
                 // Make sure aliases have been loaded
                 await GetAliases();
 
+                // We want to look for references first in referenced files, hence we use ordered dictionary
+                var fileMap = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
+                foreach(ScriptFile file in referencedFiles)
+                {
+                    fileMap.Add(file.FilePath, file);
+                }
+
+                var allFiles = workspace.EnumeratePSFiles();
+                foreach (var file in allFiles)
+                {
+                    if (!fileMap.Contains(file))
+                    {
+                        fileMap.Add(file, new ScriptFile(file, null, this.powerShellContext.LocalPowerShellVersion.Version));
+                    }
+                }
+
                 List<SymbolReference> symbolReferences = new List<SymbolReference>();
-                foreach (ScriptFile file in referencedFiles)
+                foreach (var fileName in fileMap.Keys)
                 {
+                    var file = (ScriptFile)fileMap[fileName];
                     IEnumerable<SymbolReference> symbolReferencesinFile =
                     AstOperations
                         .FindReferencesOfSymbol(
@@ -316,6 +336,8 @@ public async Task<GetDefinitionResult> GetDefinitionOfSymbol(
                 workspace.ExpandScriptReferences(
                     sourceFile);
 
+            var filesSearched = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
             // look through the referenced files until definition is found
             // or there are no more file to look through
             SymbolReference foundDefinition = null;
@@ -326,14 +348,45 @@ public async Task<GetDefinitionResult> GetDefinitionOfSymbol(
                         referencedFiles[i].ScriptAst,
                         foundSymbol);
 
+                filesSearched.Add(referencedFiles[i].FilePath);
                 if (foundDefinition != null)
                 {
                     foundDefinition.FilePath = referencedFiles[i].FilePath;
                     break;
                 }
             }
 
-            // if definition is not found in referenced files
+            // if the definition the not found in referenced files
+            // look for it in all the files in the workspace
+            if (foundDefinition == null)
+            {
+                // Get a list of all powershell files in the workspace path
+                var allFiles = workspace.EnumeratePSFiles();
+                foreach (var file in allFiles)
+                {
+                    if (filesSearched.Contains(file))
+                    {
+                        continue;
+                    }
+
+                    Token[] tokens = null;
+                    ParseError[] parseErrors = null;
+                    foundDefinition =
+                        AstOperations.FindDefinitionOfSymbol(
+                            Parser.ParseFile(file, out tokens, out parseErrors),
+                            foundSymbol);
+
+                    filesSearched.Add(file);
+                    if (foundDefinition != null)
+                    {
+                        foundDefinition.FilePath = file;
+                        break;
+                    }
+
+                }
+            }
+
+            // if definition is not found in file in the workspace
             // look for it in the builtin commands
             if (foundDefinition == null)
             {

src/PowerShellEditorServices/Workspace/ScriptFile.cs

@@ -161,14 +161,32 @@ public ScriptFile(
             string clientFilePath,
             string initialBuffer,
             Version powerShellVersion)
+            : this(
+                  filePath,
+                  clientFilePath,
+                  new StringReader(initialBuffer),
+                  powerShellVersion)
         {
-            this.FilePath = filePath;
-            this.ClientFilePath = clientFilePath;
-            this.IsAnalysisEnabled = true;
-            this.powerShellVersion = powerShellVersion;
 
-            this.SetFileContents(initialBuffer);
         }
+        /// <summary>
+        /// Creates a new ScriptFile instance with the specified filepath.
+        /// </summary>
+        /// <param name="filePath">The path at which the script file resides.</param>
+        /// <param name="clientFilePath">The path which the client uses to identify the file.</param>
+        /// <param name="powerShellVersion">The version of PowerShell for which the script is being parsed.</param>
+        public ScriptFile (
+            string filePath,
+            string clientFilePath,
+            Version powerShellVersion)
+            : this(
+                  filePath,
+                  clientFilePath,
+                  File.ReadAllText(filePath),
+                  powerShellVersion)
+            {
+
+            }
 
         #endregion
 

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -213,6 +213,28 @@ public string GetRelativePath(string filePath)
             return resolvedPath;
         }
 
+        /// <summary>
+        /// Enumerate all the PowerShell (ps1, psm1, psd1) files in the workspace in a recursive manner
+        /// </summary>
+        /// <returns>An enumerator over the PowerShell files found in the workspace</returns>
+        public IEnumerable<string> EnumeratePSFiles()
+        {
+            if (WorkspacePath == null
+                || !Directory.Exists(WorkspacePath))
+            {
+                yield break;
+            }
+
+            var patterns = new string[] { @"*.ps1", @"*.psm1", @"*.psd1" };
+            foreach(var pattern in patterns)
+            {
+                foreach (var file in Directory.EnumerateFiles(WorkspacePath, pattern, SearchOption.AllDirectories))
+                {
+                    yield return file;
+                }
+            }
+        }
+
         #endregion
 
         #region Private Methods

test/PowerShellEditorServices.Test.Shared/Definition/FindsFunctionDefinitionInWorkspace.cs

@@ -0,0 +1,20 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices;
+
+namespace Microsoft.PowerShell.EditorServices.Test.Shared.Definition
+{
+    public class FindsFunctionDefinitionInWorkspace
+    {
+        public static readonly ScriptRegion SourceDetails =
+            new ScriptRegion
+            {
+                File = @"References\ReferenceFileD.ps1",
+                StartLineNumber = 1,
+                StartColumnNumber = 2
+            };
+    }
+}

test/PowerShellEditorServices.Test.Shared/References/ReferenceFileD.ps1

@@ -0,0 +1 @@
+My-FunctionInFileE "this is my function"

test/PowerShellEditorServices.Test.Shared/References/ReferenceFileE.ps1

@@ -0,0 +1,4 @@
+function My-FunctionInFileE
+{
+
+}

test/PowerShellEditorServices.Test/Language/LanguageServiceTests.cs

@@ -23,7 +23,8 @@ public class LanguageServiceTests : IDisposable
         private Workspace workspace;
         private LanguageService languageService;
         private PowerShellContext powerShellContext;
-       
+        private const string baseSharedScriptPath = @"..\..\..\..\PowerShellEditorServices.Test.Shared\";
+
 
         public LanguageServiceTests()
         {
@@ -156,6 +157,21 @@ await this.GetDefinition(
             Assert.Equal("My-Function", definition.SymbolName);
         }
 
+        [Fact]
+        public async Task LanguageServiceFindsFunctionDefinitionInWorkspace()
+        {
+            var definitionResult =
+                await this.GetDefinition(
+                    FindsFunctionDefinitionInWorkspace.SourceDetails,
+                    new Workspace(this.powerShellContext.LocalPowerShellVersion.Version)
+                    {
+                        WorkspacePath = Path.Combine(baseSharedScriptPath, @"References")
+                    });
+            var definition = definitionResult.FoundDefinition;
+            Assert.EndsWith("ReferenceFileE.ps1", definition.FilePath);
+            Assert.Equal("My-FunctionInFileE", definition.SymbolName);
+        }
+
         [Fact]
         public async Task LanguageServiceFindsVariableDefinition()
         {
@@ -227,7 +243,7 @@ await this.GetReferences(
 
             Assert.Equal(4, refsResult.FoundReferences.Count());
         }
-        
+
         [Fact]
         public async Task LanguageServiceFindsReferencesOnFileWithReferencesFileC()
         {
@@ -297,12 +313,9 @@ public void LanguageServiceFindsSymbolsInNoSymbolsFile()
 
         private ScriptFile GetScriptFile(ScriptRegion scriptRegion)
         {
-            const string baseSharedScriptPath = 
-                @"..\..\..\..\PowerShellEditorServices.Test.Shared\";
-
             string resolvedPath =
                 Path.Combine(
-                    baseSharedScriptPath, 
+                    baseSharedScriptPath,
                     scriptRegion.File);
 
             return
@@ -329,7 +342,7 @@ await this.languageService.FindParameterSetsInFile(
                     scriptRegion.StartColumnNumber);
         }
 
-        private async Task<GetDefinitionResult> GetDefinition(ScriptRegion scriptRegion)
+        private async Task<GetDefinitionResult> GetDefinition(ScriptRegion scriptRegion, Workspace workspace)
         {
             ScriptFile scriptFile = GetScriptFile(scriptRegion);
 
@@ -345,7 +358,12 @@ private async Task<GetDefinitionResult> GetDefinition(ScriptRegion scriptRegion)
                 await this.languageService.GetDefinitionOfSymbol(
                     scriptFile,
                     symbolReference,
-                    this.workspace);
+                    workspace);
+        }
+
+        private async Task<GetDefinitionResult> GetDefinition(ScriptRegion scriptRegion)
+        {
+            return await GetDefinition(scriptRegion, this.workspace);
         }
 
         private async Task<FindReferencesResult> GetReferences(ScriptRegion scriptRegion)
@@ -363,11 +381,12 @@ private async Task<FindReferencesResult> GetReferences(ScriptRegion scriptRegion
             return
                 await this.languageService.FindReferencesOfSymbol(
                     symbolReference,
-                    this.workspace.ExpandScriptReferences(scriptFile));
+                    this.workspace.ExpandScriptReferences(scriptFile),
+                    this.workspace);
         }
 
         private FindOccurrencesResult GetOccurrences(ScriptRegion scriptRegion)
-        { 
+        {
             return
                 this.languageService.FindOccurrencesInFile(
                     GetScriptFile(scriptRegion),