/// <summary>
/// Gets all aliases found in the runspace
/// </summary>
private async Task GetAliasesAsync()
{
if (_areAliasesLoaded)
{
return;
}
await _aliasHandle.WaitAsync();
try
{
if (_powerShellContext.IsCurrentRunspaceOutOfProcess())
{
_areAliasesLoaded = true;
return;
}
var aliases = await _powerShellContext.ExecuteCommandAsync <AliasInfo>(
new PSCommand()
.AddCommand("Microsoft.PowerShell.Core\\Get-Command")
.AddParameter("CommandType", CommandTypes.Alias),
sendOutputToHost : false,
sendErrorToHost : false);
foreach (AliasInfo aliasInfo in aliases)
{
// Using Get-Command will obtain aliases from modules not yet loaded,
// these aliases will not have a definition.
if (string.IsNullOrEmpty(aliasInfo.Definition))
{
continue;
}
if (!_cmdletToAliasDictionary.ContainsKey(aliasInfo.Definition))
{
_cmdletToAliasDictionary.Add(aliasInfo.Definition, new List <String> {
aliasInfo.Name
});
}
else
{
_cmdletToAliasDictionary[aliasInfo.Definition].Add(aliasInfo.Name);
}
_aliasToCmdletDictionary.Add(aliasInfo.Name, aliasInfo.Definition);
}
_areAliasesLoaded = true;
}
catch (PSNotSupportedException e)
{
_logger.Write(
LogLevel.Warning,
$"Caught PSNotSupportedException while attempting to get aliases from remote session:\n\n{e.ToString()}");
// Prevent the aliases from being fetched again - no point if the remote doesn't support InvokeCommand.
_areAliasesLoaded = true;
}
catch (TaskCanceledException)
{
// The wait for a RunspaceHandle has timed out, skip aliases for now
}
finally
{
_aliasHandle.Release();
}
}
/// <summary>
/// Gets completions for the symbol found in the Ast at
/// the given file offset.
/// </summary>
/// <param name="scriptAst">
/// The Ast which will be traversed to find a completable symbol.
/// </param>
/// <param name="currentTokens">
/// The array of tokens corresponding to the scriptAst parameter.
/// </param>
/// <param name="fileOffset">
/// The 1-based file offset at which a symbol will be located.
/// </param>
/// <param name="powerShellContext">
/// The PowerShellContext to use for gathering completions.
/// </param>
/// <param name="logger">An ILogger implementation used for writing log messages.</param>
/// <param name="cancellationToken">
/// A CancellationToken to cancel completion requests.
/// </param>
/// <returns>
/// A CommandCompletion instance that contains completions for the
/// symbol at the given offset.
/// </returns>
static public async Task <CommandCompletion> GetCompletionsAsync(
Ast scriptAst,
Token[] currentTokens,
int fileOffset,
PowerShellContext powerShellContext,
ILogger logger,
CancellationToken cancellationToken)
{
if (!s_completionHandle.Wait(0))
{
return(null);
}
try
{
IScriptPosition cursorPosition = (IScriptPosition)s_extentCloneWithNewOffset.Invoke(
scriptAst.Extent.StartScriptPosition,
new object[] { fileOffset });
logger.Write(
LogLevel.Verbose,
string.Format(
"Getting completions at offset {0} (line: {1}, column: {2})",
fileOffset,
cursorPosition.LineNumber,
cursorPosition.ColumnNumber));
if (!powerShellContext.IsAvailable)
{
return(null);
}
var stopwatch = new Stopwatch();
// If the current runspace is out of process we can use
// CommandCompletion.CompleteInput because PSReadLine won't be taking up the
// main runspace.
if (powerShellContext.IsCurrentRunspaceOutOfProcess())
{
using (RunspaceHandle runspaceHandle = await powerShellContext.GetRunspaceHandleAsync(cancellationToken))
using (PowerShell powerShell = PowerShell.Create())
{
powerShell.Runspace = runspaceHandle.Runspace;
stopwatch.Start();
try
{
return(CommandCompletion.CompleteInput(
scriptAst,
currentTokens,
cursorPosition,
options: null,
powershell: powerShell));
}
finally
{
stopwatch.Stop();
logger.Write(LogLevel.Verbose, $"IntelliSense completed in {stopwatch.ElapsedMilliseconds}ms.");
}
}
}
CommandCompletion commandCompletion = null;
await powerShellContext.InvokeOnPipelineThreadAsync(
pwsh =>
{
stopwatch.Start();
commandCompletion = CommandCompletion.CompleteInput(
scriptAst,
currentTokens,
cursorPosition,
options: null,
powershell: pwsh);
});
stopwatch.Stop();
logger.Write(LogLevel.Verbose, $"IntelliSense completed in {stopwatch.ElapsedMilliseconds}ms.");
return(commandCompletion);
}
finally
{
s_completionHandle.Release();
}
}