/// <summary>
/// Finds the definition of a symbol in the script file or any of the
/// files that it references.
/// </summary>
/// <param name="sourceFile">The initial script file to be searched for the symbol's definition.</param>
/// <param name="foundSymbol">The symbol for which a definition will be found.</param>
/// <param name="workspace">The Workspace to which the ScriptFile belongs.</param>
/// <returns>The resulting GetDefinitionResult for the symbol's definition.</returns>
public async Task <GetDefinitionResult> GetDefinitionOfSymbol(
ScriptFile sourceFile,
SymbolReference foundSymbol,
Workspace workspace)
{
Validate.IsNotNull("sourceFile", sourceFile);
Validate.IsNotNull("foundSymbol", foundSymbol);
Validate.IsNotNull("workspace", workspace);
ScriptFile[] referencedFiles =
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;
for (int i = 0; i < referencedFiles.Length; i++)
{
foundDefinition =
AstOperations.FindDefinitionOfSymbol(
referencedFiles[i].ScriptAst,
foundSymbol);
filesSearched.Add(referencedFiles[i].FilePath);
if (foundDefinition != null)
{
foundDefinition.FilePath = referencedFiles[i].FilePath;
break;
}
}
// 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)
{
CommandInfo cmdInfo =
await CommandHelpers.GetCommandInfo(
foundSymbol.SymbolName,
this.powerShellContext);
foundDefinition =
FindDeclarationForBuiltinCommand(
cmdInfo,
foundSymbol,
workspace);
}
return(foundDefinition != null ?
new GetDefinitionResult(foundDefinition) :
null);
}
/// <summary>
/// Finds all the references of a symbol
/// </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,
Workspace workspace)
{
if (foundSymbol != null)
{
int symbolOffset = referencedFiles[0].GetOffsetAtPosition(
foundSymbol.ScriptRegion.StartLineNumber,
foundSymbol.ScriptRegion.StartColumnNumber);
// 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 (var fileName in fileMap.Keys)
{
var file = (ScriptFile)fileMap[fileName];
IEnumerable <SymbolReference> symbolReferencesinFile =
AstOperations
.FindReferencesOfSymbol(
file.ScriptAst,
foundSymbol,
CmdletToAliasDictionary,
AliasToCmdletDictionary)
.Select(
reference =>
{
try
{
reference.SourceLine =
file.GetLine(reference.ScriptRegion.StartLineNumber);
}
catch (ArgumentOutOfRangeException e)
{
reference.SourceLine = string.Empty;
this.logger.WriteException("Found reference is out of range in script file", e);
}
reference.FilePath = file.FilePath;
return(reference);
});
symbolReferences.AddRange(symbolReferencesinFile);
}
return
(new FindReferencesResult
{
SymbolFileOffset = symbolOffset,
SymbolName = foundSymbol.SymbolName,
FoundReferences = symbolReferences
});
}
else
{
return(null);
}
}
/// <summary>
/// Finds all the references of a symbol
/// </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> FindReferencesOfSymbolAsync(
SymbolReference foundSymbol,
ScriptFile[] referencedFiles,
Workspace workspace)
{
if (foundSymbol == null)
{
return(null);
}
int symbolOffset = referencedFiles[0].GetOffsetAtPosition(
foundSymbol.ScriptRegion.StartLineNumber,
foundSymbol.ScriptRegion.StartColumnNumber);
// Make sure aliases have been loaded
await GetAliasesAsync();
// 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
var fileMap = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
? new OrderedDictionary()
: new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
foreach (ScriptFile scriptFile in referencedFiles)
{
fileMap[scriptFile.FilePath] = scriptFile;
}
foreach (string filePath in workspace.EnumeratePSFiles())
{
if (!fileMap.Contains(filePath))
{
if (!workspace.TryGetFile(filePath, out ScriptFile scriptFile))
{
// If we can't access the file for some reason, just ignore it
continue;
}
fileMap[filePath] = scriptFile;
}
}
var symbolReferences = new List <SymbolReference>();
foreach (object fileName in fileMap.Keys)
{
var file = (ScriptFile)fileMap[fileName];
await _aliasHandle.WaitAsync();
try
{
IEnumerable <SymbolReference> references = AstOperations.FindReferencesOfSymbol(
file.ScriptAst,
foundSymbol,
_cmdletToAliasDictionary,
_aliasToCmdletDictionary);
foreach (SymbolReference reference in references)
{
try
{
reference.SourceLine = file.GetLine(reference.ScriptRegion.StartLineNumber);
}
catch (ArgumentOutOfRangeException e)
{
reference.SourceLine = string.Empty;
_logger.WriteException("Found reference is out of range in script file", e);
}
reference.FilePath = file.FilePath;
symbolReferences.Add(reference);
}
}
finally
{
_aliasHandle.Release();
}
}
return(new FindReferencesResult
{
SymbolFileOffset = symbolOffset,
SymbolName = foundSymbol.SymbolName,
FoundReferences = symbolReferences
});
}
/// <summary>
/// Finds the definition of a symbol in the script file or any of the
/// files that it references.
/// </summary>
/// <param name="sourceFile">The initial script file to be searched for the symbol's definition.</param>
/// <param name="foundSymbol">The symbol for which a definition will be found.</param>
/// <param name="workspace">The Workspace to which the ScriptFile belongs.</param>
/// <returns>The resulting GetDefinitionResult for the symbol's definition.</returns>
public async Task <GetDefinitionResult> GetDefinitionOfSymbolAsync(
ScriptFile sourceFile,
SymbolReference foundSymbol,
Workspace workspace)
{
Validate.IsNotNull(nameof(sourceFile), sourceFile);
Validate.IsNotNull(nameof(foundSymbol), foundSymbol);
Validate.IsNotNull(nameof(workspace), workspace);
ScriptFile[] referencedFiles =
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;
foreach (ScriptFile scriptFile in referencedFiles)
{
foundDefinition =
AstOperations.FindDefinitionOfSymbol(
scriptFile.ScriptAst,
foundSymbol);
filesSearched.Add(scriptFile.FilePath);
if (foundDefinition != null)
{
foundDefinition.FilePath = scriptFile.FilePath;
break;
}
if (foundSymbol.SymbolType == SymbolType.Function)
{
// Dot-sourcing is parsed as a "Function" Symbol.
string dotSourcedPath = GetDotSourcedPath(foundSymbol, workspace, scriptFile);
if (scriptFile.FilePath == dotSourcedPath)
{
foundDefinition = new SymbolReference(SymbolType.Function, foundSymbol.SymbolName, scriptFile.ScriptAst.Extent, scriptFile.FilePath);
break;
}
}
}
// 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
IEnumerable <string> allFiles = workspace.EnumeratePSFiles();
foreach (string 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)
{
CommandInfo cmdInfo =
await CommandHelpers.GetCommandInfoAsync(
foundSymbol.SymbolName,
_powerShellContext);
foundDefinition =
FindDeclarationForBuiltinCommand(
cmdInfo,
foundSymbol,
workspace);
}
return(foundDefinition != null ?
new GetDefinitionResult(foundDefinition) :
null);
}
/// <summary>
/// Finds all the references of a symbol
/// </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,
Workspace workspace)
{
if (foundSymbol == null)
{
return(null);
}
int symbolOffset = referencedFiles[0].GetOffsetAtPosition(
foundSymbol.ScriptRegion.StartLineNumber,
foundSymbol.ScriptRegion.StartColumnNumber);
// Make sure aliases have been loaded
await GetAliases();
// 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
#if CoreCLR
// The RuntimeInformation.IsOSPlatform is not supported in .NET Framework
var fileMap = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
? new OrderedDictionary()
: new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
#else
var fileMap = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
#endif
foreach (ScriptFile file in referencedFiles)
{
fileMap.Add(file.FilePath, file);
}
foreach (string file in workspace.EnumeratePSFiles())
{
if (!fileMap.Contains(file))
{
ScriptFile scriptFile;
try
{
scriptFile = workspace.GetFile(file);
}
catch (Exception e) when(e is IOException ||
e is SecurityException ||
e is FileNotFoundException ||
e is DirectoryNotFoundException ||
e is PathTooLongException ||
e is UnauthorizedAccessException)
{
// If we can't access the file for some reason, just ignore it
continue;
}
fileMap.Add(file, scriptFile);
}
}
var symbolReferences = new List <SymbolReference>();
foreach (object fileName in fileMap.Keys)
{
var file = (ScriptFile)fileMap[fileName];
IEnumerable <SymbolReference> references = AstOperations.FindReferencesOfSymbol(
file.ScriptAst,
foundSymbol,
_cmdletToAliasDictionary,
_aliasToCmdletDictionary);
foreach (SymbolReference reference in references)
{
try
{
reference.SourceLine = file.GetLine(reference.ScriptRegion.StartLineNumber);
}
catch (ArgumentOutOfRangeException e)
{
reference.SourceLine = string.Empty;
_logger.WriteException("Found reference is out of range in script file", e);
}
reference.FilePath = file.FilePath;
symbolReferences.Add(reference);
}
}
return(new FindReferencesResult
{
SymbolFileOffset = symbolOffset,
SymbolName = foundSymbol.SymbolName,
FoundReferences = symbolReferences
});
}