Remove notion of ReferencedFiles

This has been unused and sometimes broken,
it doesn't actually power any useful features.

Author: andyleejordan

src/PowerShellEditorServices/Services/CodeLens/ReferencesCodeLensProvider.cs

@@ -97,18 +97,14 @@ public async Task<CodeLens> ResolveCodeLens(
             ScriptFile scriptFile,
             CancellationToken cancellationToken)
         {
-            ScriptFile[] references = _workspaceService.ExpandScriptReferences(scriptFile);
-
             SymbolReference foundSymbol = SymbolsService.FindSymbolDefinitionAtLocation(
                 scriptFile,
                 codeLens.Range.Start.Line + 1,
                 codeLens.Range.Start.Character + 1);
 
             IEnumerable<SymbolReference> referencesResult =
                 await _symbolsService.ScanForReferencesOfSymbol(
-                    foundSymbol,
-                    references,
-                    cancellationToken).ConfigureAwait(false);
+                    foundSymbol, cancellationToken).ConfigureAwait(false);
 
             Location[] referenceLocations;
             if (referencesResult == null)

src/PowerShellEditorServices/Services/Symbols/SymbolsService.cs

@@ -4,11 +4,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -154,12 +152,10 @@ public static SymbolReference FindSymbolAtLocation(
         /// Finds all the references of a symbol (excluding definitions)
         /// </summary>
         /// <param name="foundSymbol">The symbol to find all references for</param>
-        /// <param name="referencedFiles">An array of scriptFiles to search for references in</param>
         /// <param name="cancellationToken"></param>
         /// <returns>FindReferencesResult</returns>
         public async Task<IEnumerable<SymbolReference>> ScanForReferencesOfSymbol(
             SymbolReference foundSymbol,
-            ScriptFile[] referencedFiles,
             CancellationToken cancellationToken = default)
         {
             if (foundSymbol == null)
@@ -182,21 +178,6 @@ public async Task<IEnumerable<SymbolReference>> ScanForReferencesOfSymbol(
                 }
             }
 
-            // TODO: This is entirely unused, but we actually DO want to search first the file, then
-            // its referenced files, then everything else!
-            //
-            // We want to look for references first in referenced files, hence we use ordered
-            // dictionary TODO: File system case-sensitivity is based on filesystem not OS, but OS
-            // is a much cheaper heuristic
-            OrderedDictionary fileMap = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
-                ? new OrderedDictionary()
-                : new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
-
-            foreach (ScriptFile scriptFile in referencedFiles)
-            {
-                fileMap[scriptFile.FilePath] = scriptFile;
-            }
-
             await ScanWorkspacePSFiles(cancellationToken).ConfigureAwait(false);
 
             List<SymbolReference> symbolReferences = new();
@@ -419,7 +400,6 @@ public async Task<IEnumerable<SymbolReference>> GetDefinitionOfSymbolAsync(
 
             IEnumerable<SymbolReference> allSymbols = await ScanForReferencesOfSymbol(
                 symbol,
-                _workspaceService.ExpandScriptReferences(file),
                 cancellationToken).ConfigureAwait(false);
 
             IEnumerable<SymbolReference> possibleDeclarations = allSymbols.Where((i) => i.IsDeclaration);

src/PowerShellEditorServices/Services/TextDocument/Handlers/ReferencesHandler.cs

@@ -43,9 +43,7 @@ public override async Task<LocationContainer> Handle(ReferenceParams request, Ca
 
             IEnumerable<SymbolReference> referencesResult =
                 await _symbolsService.ScanForReferencesOfSymbol(
-                    foundSymbol,
-                    _workspaceService.ExpandScriptReferences(scriptFile),
-                    cancellationToken).ConfigureAwait(false);
+                    foundSymbol, cancellationToken).ConfigureAwait(false);
 
             if (referencesResult is null)
             {

src/PowerShellEditorServices/Services/TextDocument/ScriptFile.cs

@@ -7,7 +7,6 @@
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Language;
-using Microsoft.PowerShell.EditorServices.Services.Symbols;
 using Microsoft.PowerShell.EditorServices.Utility;
 using OmniSharp.Extensions.LanguageServer.Protocol;
 
@@ -111,15 +110,6 @@ public Token[] ScriptTokens
             private set;
         }
 
-        /// <summary>
-        /// Gets the array of filepaths dot sourced in this ScriptFile
-        /// </summary>
-        public string[] ReferencedFiles
-        {
-            get;
-            private set;
-        }
-
         internal ReferenceTable References { get; }
 
         internal bool IsOpen { get; set; }
@@ -600,21 +590,6 @@ private void ParseFileContents()
                 parseErrors
                     .Select(ScriptFileMarker.FromParseError)
                     .ToList();
-
-            // Untitled files have no directory
-            // Discussed in https://github.com/PowerShell/PowerShellEditorServices/pull/815.
-            // Rather than working hard to enable things for untitled files like a phantom directory,
-            // users should save the file.
-            if (IsInMemory)
-            {
-                // Need to initialize the ReferencedFiles property to an empty array.
-                ReferencedFiles = Array.Empty<string>();
-                return;
-            }
-
-            // Get all dot sourced referenced files and store them
-            // TODO: We're considering removing this notion.
-            ReferencedFiles = AstOperations.FindDotSourcedIncludes(ScriptAst, Path.GetDirectoryName(FilePath));
         }
 
         #endregion

src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs

@@ -292,35 +292,6 @@ public void CloseFile(ScriptFile scriptFile)
             workspaceFiles.TryRemove(keyName, out ScriptFile _);
         }
 
-        /// <summary>
-        /// Gets all file references by recursively searching
-        /// through referenced files in a scriptfile
-        /// </summary>
-        /// <param name="scriptFile">Contains the details and contents of an open script file</param>
-        /// <returns>A scriptfile array where the first file
-        /// in the array is the "root file" of the search</returns>
-        public ScriptFile[] ExpandScriptReferences(ScriptFile scriptFile)
-        {
-            Dictionary<string, ScriptFile> referencedScriptFiles = new();
-            List<ScriptFile> expandedReferences = new();
-
-            // add original file so it's not searched for, then find all file references
-            referencedScriptFiles.Add(scriptFile.Id, scriptFile);
-            RecursivelyFindReferences(scriptFile, referencedScriptFiles);
-
-            // remove original file from referenced file and add it as the first element of the
-            // expanded referenced list to maintain order so the original file is always first in the list
-            referencedScriptFiles.Remove(scriptFile.Id);
-            expandedReferences.Add(scriptFile);
-
-            if (referencedScriptFiles.Count > 0)
-            {
-                expandedReferences.AddRange(referencedScriptFiles.Values);
-            }
-
-            return expandedReferences.ToArray();
-        }
-
         /// <summary>
         /// Gets the workspace-relative path of the given file path.
         /// </summary>
@@ -401,54 +372,6 @@ bool ignoreReparsePoints
         #endregion
 
         #region Private Methods
-        /// <summary>
-        /// Recursively searches through referencedFiles in scriptFiles
-        /// and builds a Dictionary of the file references
-        /// </summary>
-        /// <param name="scriptFile">Details an contents of "root" script file</param>
-        /// <param name="referencedScriptFiles">A Dictionary of referenced script files</param>
-        private void RecursivelyFindReferences(
-            ScriptFile scriptFile,
-            Dictionary<string, ScriptFile> referencedScriptFiles)
-        {
-            // Get the base path of the current script for use in resolving relative paths
-            string baseFilePath = scriptFile.IsInMemory
-                ? WorkspacePath
-                : Path.GetDirectoryName(scriptFile.FilePath);
-
-            foreach (string referencedFileName in scriptFile.ReferencedFiles)
-            {
-                string resolvedScriptPath =
-                    ResolveRelativeScriptPath(
-                        baseFilePath,
-                        referencedFileName);
-
-                // If there was an error resolving the string, skip this reference
-                if (resolvedScriptPath == null)
-                {
-                    continue;
-                }
-
-                logger.LogDebug(
-                    string.Format(
-                        "Resolved relative path '{0}' to '{1}'",
-                        referencedFileName,
-                        resolvedScriptPath));
-
-                // Get the referenced file if it's not already in referencedScriptFiles
-                if (TryGetFile(resolvedScriptPath, out ScriptFile referencedFile))
-                {
-                    // Normalize the resolved script path and add it to the
-                    // referenced files list if it isn't there already
-                    resolvedScriptPath = resolvedScriptPath.ToLower();
-                    if (!referencedScriptFiles.ContainsKey(resolvedScriptPath))
-                    {
-                        referencedScriptFiles.Add(resolvedScriptPath, referencedFile);
-                        RecursivelyFindReferences(referencedFile, referencedScriptFiles);
-                    }
-                }
-            }
-        }
 
         internal static StreamReader OpenStreamReader(DocumentUri uri)
         {

test/PowerShellEditorServices.Test/Language/SymbolsServiceTests.cs

@@ -109,9 +109,7 @@ private async Task<List<SymbolReference>> GetReferences(ScriptRegion scriptRegio
             Assert.NotNull(symbol);
 
             IEnumerable<SymbolReference> symbols =
-                await symbolsService.ScanForReferencesOfSymbol(
-                    symbol,
-                    workspace.ExpandScriptReferences(scriptFile)).ConfigureAwait(true);
+                await symbolsService.ScanForReferencesOfSymbol(symbol).ConfigureAwait(true);
 
             return symbols.OrderBy(i => i.ScriptRegion.ToRange().Start).ToList();
         }

test/PowerShellEditorServices.Test/Session/ScriptFileTests.cs

@@ -174,30 +174,6 @@ public void CanAppendToEndOfFile()
             );
         }
 
-        [Trait("Category", "ScriptFile")]
-        [Fact]
-        public void FindsDotSourcedFiles()
-        {
-            string exampleScriptContents = TestUtilities.PlatformNormalize(
-                ". ./athing.ps1\n" +
-                ". ./somefile.ps1\n" +
-                ". ./somefile.ps1\n" +
-                "Do-Stuff $uri\n" +
-                ". simpleps.ps1");
-
-            using StringReader stringReader = new(exampleScriptContents);
-            ScriptFile scriptFile =
-                new(
-                    // Use any absolute path. Even if it doesn't exist.
-                    DocumentUri.FromFileSystemPath(Path.Combine(Path.GetTempPath(), "TestFile.ps1")),
-                    stringReader,
-                    PowerShellVersion);
-
-            Assert.Equal(3, scriptFile.ReferencedFiles.Length);
-            Console.Write("a" + scriptFile.ReferencedFiles[0]);
-            Assert.Equal(TestUtilities.NormalizePath("./athing.ps1"), scriptFile.ReferencedFiles[0]);
-        }
-
         [Trait("Category", "ScriptFile")]
         [Fact]
         public void ThrowsExceptionWithEditOutsideOfRange()
@@ -610,7 +586,6 @@ public void PropertiesInitializedCorrectlyForFile()
             Assert.Equal(path, scriptFile.FilePath, ignoreCase: !VersionUtils.IsLinux);
             Assert.True(scriptFile.IsAnalysisEnabled);
             Assert.False(scriptFile.IsInMemory);
-            Assert.Empty(scriptFile.ReferencedFiles);
             Assert.Empty(scriptFile.DiagnosticMarkers);
             Assert.Single(scriptFile.ScriptTokens);
             Assert.Single(scriptFile.FileLines);
@@ -635,7 +610,6 @@ public void PropertiesInitializedCorrectlyForUntitled()
             Assert.Equal(path, scriptFile.DocumentUri);
             Assert.True(scriptFile.IsAnalysisEnabled);
             Assert.True(scriptFile.IsInMemory);
-            Assert.Empty(scriptFile.ReferencedFiles);
             Assert.Empty(scriptFile.DiagnosticMarkers);
             Assert.Equal(10, scriptFile.ScriptTokens.Length);
             Assert.Equal(3, scriptFile.FileLines.Count);