/// <summary>
/// IsForeachScriptBlock: Returns true if:
/// - command is 'Foreach-Object' (or alias)
/// - parameter '-Parallel' is present
/// </summary>
/// <param name="cmdName"></param>
/// <param name="scriptBlockParameterAst"></param>
private bool IsForeachScriptBlock(string cmdName, CommandParameterAst scriptBlockParameterAst)
{
// 'pa' is the shortest unambiguous form for the '-Parallel' parameter
return(s_foreachObjectCmdletNamesAndAliases.Contains(cmdName, StringComparer.OrdinalIgnoreCase) &&
(scriptBlockParameterAst != null &&
scriptBlockParameterAst.ParameterName.StartsWith("pa", StringComparison.OrdinalIgnoreCase)));
}
private void AddParameter(CommandParameterAst commandParameterAst, bool isTrustedInput)
{
string nameSuffix;
object argument;
if (commandParameterAst.Argument != null)
{
var arg = commandParameterAst.Argument;
var errorPos = commandParameterAst.ErrorPosition;
bool spaceAfterParameter = (errorPos.EndLineNumber != arg.Extent.StartLineNumber ||
errorPos.EndColumnNumber != arg.Extent.StartColumnNumber);
nameSuffix = spaceAfterParameter ? ": " : ":";
argument = GetExpressionValue(commandParameterAst.Argument, isTrustedInput);
}
else
{
nameSuffix = string.Empty;
argument = null;
}
// first character in parameter name must be a dash
_powershell.AddParameter(
string.Format(CultureInfo.InvariantCulture, "-{0}{1}", commandParameterAst.ParameterName, nameSuffix),
argument);
}
public object VisitCommandParameter(CommandParameterAst commandParameterAst)
{
var newArgument = VisitElement(commandParameterAst.Argument);
return(new CommandParameterAst(commandParameterAst.Extent, commandParameterAst.ParameterName, newArgument,
commandParameterAst.ErrorPosition));
}
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
CommandAst commandParentAst = commandParameterAst.Parent as CommandAst;
if (commandParentAst != null &&
String.Equals(commandParentAst.GetCommandName(), "Import-DscResource", StringComparison.OrdinalIgnoreCase))
{
// Resource can be specified by name, without a module.
if (String.Equals(commandParameterAst.ParameterName, "Name", StringComparison.OrdinalIgnoreCase))
{
ArrayLiteralAst arrayLiteralAst = commandParameterAst.Argument as ArrayLiteralAst;
if (arrayLiteralAst != null)
{
IEnumerable <string> resourceNames = arrayLiteralAst.Elements.OfType <StringConstantExpressionAst>().Select(x => x.Value);
foreach (string resourceName in resourceNames)
{
}
}
}
// Or with ModuleDefinition parameter
else if (String.Equals(commandParameterAst.ParameterName, "ModuleDefinition", StringComparison.OrdinalIgnoreCase))
{
ArrayLiteralAst arrayLiteralAst = commandParameterAst.Argument as ArrayLiteralAst;
if (arrayLiteralAst != null)
{
Modules.AddRange(arrayLiteralAst.Elements.OfType <StringConstantExpressionAst>().Select(x => x.Value));
}
}
}
return(base.VisitCommandParameter(commandParameterAst));
}
/// <summary>
/// Condition on the parameter that must be satisfied for the error to be raised.
/// </summary>
/// <param name="CmdAst"></param>
/// <param name="CeAst"></param>
/// <returns></returns>
public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst)
{
if (CeAst is CommandParameterAst)
{
CommandParameterAst cmdParamAst = CeAst as CommandParameterAst;
if (String.Equals(cmdParamAst.ParameterName, "computername", StringComparison.OrdinalIgnoreCase))
{
Ast computerNameArgument = cmdParamAst.Argument;
if (computerNameArgument == null)
{
computerNameArgument = GetComputerNameArg(CmdAst, cmdParamAst.Extent.StartOffset);
if (computerNameArgument == null)
{
return(false);
}
}
var constExprAst = computerNameArgument as ConstantExpressionAst;
if (constExprAst != null)
{
return(!IsLocalhost(constExprAst));
}
}
}
return(false);
}
/// <summary>
/// Condition on the parameter that must be satisfied for the error to be raised.
/// </summary>
/// <param name="CmdAst"></param>
/// <param name="CeAst"></param>
/// <returns></returns>
public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst)
{
if (CeAst is CommandParameterAst)
{
CommandParameterAst cmdParamAst = CeAst as CommandParameterAst;
if (String.Equals(cmdParamAst.ParameterName, "computername", StringComparison.OrdinalIgnoreCase))
{
List <string> localhostRepresentations = new List <string> {
"localhost", ".", "::1", "127.0.0.1"
};
Ast computerNameArgument = GetComputerNameArg(CmdAst, cmdParamAst.Extent.StartOffset);
if (null != computerNameArgument)
{
if (!localhostRepresentations.Contains(computerNameArgument.Extent.Text.ToLower()))
{
return(computerNameArgument is ConstantExpressionAst);
}
return(false);
}
if (null != cmdParamAst.Argument && !localhostRepresentations.Contains(cmdParamAst.Argument.ToString().Replace("\"", "").Replace("'", "").ToLower()))
{
return(cmdParamAst.Argument is ConstantExpressionAst);
}
}
}
return(false);
}
public ParameterSet(CommandAst commandAst)
{
Validation.CheckArgument(commandAst, $"{nameof(commandAst)} cannot be null.");
var parameters = new List <Parameter>();
CommandParameterAst param = null;
Ast arg = null;
// Loop through all the parameters. The first element of CommandElements is the command name, so skip it.
for (var i = 1; i < commandAst.CommandElements.Count(); ++i)
{
var elem = commandAst.CommandElements[i];
if (elem is CommandParameterAst p)
{
AddParameter(param, arg);
param = p;
arg = null;
}
else if (AzPredictorConstants.ParameterIndicator == elem?.ToString().Trim().FirstOrDefault())
{
// We have an incomplete command line such as
// `New-AzResourceGroup -Name ResourceGroup01 -Location WestUS -`
// We'll ignore the incomplete parameter.
AddParameter(param, arg);
param = null;
arg = null;
}
else
{
arg = elem;
}
}
Validation.CheckInvariant((param != null) || (arg == null));
AddParameter(param, arg);
Parameters = parameters;
void AddParameter(CommandParameterAst parameter, Ast parameterValue)
{
if (parameter != null)
{
var value = parameterValue?.ToString();
if (value == null)
{
value = parameter.Argument?.ToString();
}
if (value != null)
{
value = CommandLineUtilities.UnescapePredictionText(value);
}
parameters.Add(new Parameter(parameter.ParameterName, value));
}
}
}
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
if (commandParameterAst.ToString().Contains(symbolRef.ScriptRegion.Text))
{
ValidateExtend(symbolRef.ScriptRegion.Text, commandParameterAst.ParameterName, commandParameterAst);
}
return(base.VisitCommandParameter(commandParameterAst));
}
/// <summary>
/// IsJobScriptBlock: Returns true if:
/// - command is 'Start-Job' or 'Start-ThreadJob' (or alias)
/// - parameter name for this ScriptBlock not '-InitializationScript'
/// </summary>
/// <param name="cmdName"></param>
/// <param name="scriptBlockParameterAst"></param>
private bool IsJobScriptBlock(string cmdName, CommandParameterAst scriptBlockParameterAst)
{
// 'ini' is the shortest unambiguous form for the '-InitializationScript' parameter
return((s_jobCmdletNamesAndAliases.Contains(cmdName, StringComparer.OrdinalIgnoreCase) ||
s_threadJobCmdletNamesAndAliases.Contains(cmdName, StringComparer.OrdinalIgnoreCase)) &&
!(scriptBlockParameterAst != null &&
scriptBlockParameterAst.ParameterName.StartsWith("ini", StringComparison.OrdinalIgnoreCase)));
}
public virtual CommandElementAst VisitCommandParameter(CommandParameterAst commandParameterAst)
{
return(new CommandParameterAst(
commandParameterAst.Extent,
commandParameterAst.ParameterName,
commandParameterAst.Argument?.Rewrite(this),
commandParameterAst.ErrorPosition));
}
/// <summary>
/// Decides if the current function definition is a reference of the symbol being searched for.
/// A reference of the symbol will be a of type SymbolType.Parameter and have the same name as the symbol
/// </summary>
/// <param name="commandParameterAst">A commandParameterAst in the script's AST</param>
/// <returns>A visit action that continues the search for references</returns>
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
if (_symbolRef.SymbolType.Equals(SymbolType.Parameter) &&
commandParameterAst.Extent.Text.Equals(_symbolRef.SymbolName, StringComparison.CurrentCultureIgnoreCase))
{
FoundReferences.Add(new SymbolReference(SymbolType.Parameter, commandParameterAst.Extent));
}
return(AstVisitAction.Continue);
}
private static bool IsParameterName(CommandElementAst ast, string name)
{
CommandParameterAst constantAst = ast as CommandParameterAst;
if (constantAst == null)
{
return(false);
}
return(String.Equals(constantAst.ParameterName, name, StringComparison.OrdinalIgnoreCase));
}
public static CommandParameterAst Update(
this CommandParameterAst ast,
string parameterName = null,
ExpressionAst argument = null)
{
return(new CommandParameterAst(
ast.Extent,
parameterName ?? ast.ParameterName,
argument?.Clone() ?? ast.Argument?.Clone(),
ast.ErrorPosition));
}
internal static SteppablePipeline GetSteppablePipeline(PipelineAst pipelineAst, CommandOrigin commandOrigin)
{
PipelineProcessor pipe = new PipelineProcessor();
System.Management.Automation.ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
foreach (CommandAst ast in pipelineAst.PipelineElements.Cast <CommandAst>())
{
List <CommandParameterInternal> list = new List <CommandParameterInternal>();
foreach (CommandElementAst ast2 in ast.CommandElements)
{
CommandParameterAst commandParameterAst = ast2 as CommandParameterAst;
if (commandParameterAst != null)
{
list.Add(GetCommandParameter(commandParameterAst, executionContextFromTLS));
}
else
{
ExpressionAst expressionAst = (ExpressionAst)ast2;
object obj2 = Compiler.GetExpressionValue(expressionAst, executionContextFromTLS, (IList)null);
bool splatted = (expressionAst is VariableExpressionAst) && ((VariableExpressionAst)expressionAst).Splatted;
list.Add(CommandParameterInternal.CreateArgument(expressionAst.Extent, obj2, splatted));
}
}
List <CommandRedirection> list2 = new List <CommandRedirection>();
foreach (RedirectionAst ast5 in ast.Redirections)
{
list2.Add(GetCommandRedirection(ast5, executionContextFromTLS));
}
CommandProcessorBase base2 = AddCommand(pipe, list.ToArray(), ast, list2.ToArray(), executionContextFromTLS);
base2.Command.CommandOriginInternal = commandOrigin;
base2.CommandScope.ScopeOrigin = commandOrigin;
base2.Command.MyInvocation.CommandOrigin = commandOrigin;
CallStackFrame[] frameArray = executionContextFromTLS.Debugger.GetCallStack().ToArray <CallStackFrame>();
if ((frameArray.Length > 0) && Regex.IsMatch(frameArray[0].Position.Text, "GetSteppablePipeline", RegexOptions.IgnoreCase))
{
InvocationInfo myInvocation = base2.Command.MyInvocation;
myInvocation.InvocationName = frameArray[0].InvocationInfo.InvocationName;
if (frameArray.Length > 1)
{
IScriptExtent position = frameArray[1].Position;
if ((position != null) && (position != PositionUtilities.EmptyExtent))
{
myInvocation.DisplayScriptPosition = position;
}
}
}
if ((executionContextFromTLS.CurrentCommandProcessor != null) && (executionContextFromTLS.CurrentCommandProcessor.CommandRuntime != null))
{
base2.CommandRuntime.SetMergeFromRuntime(executionContextFromTLS.CurrentCommandProcessor.CommandRuntime);
}
}
return(new SteppablePipeline(executionContextFromTLS, pipe));
}
/// <summary>
/// Checks to see if this command parameter is the symbol we are looking for.
/// </summary>
/// <param name="commandParameterAst">A CommandParameterAst object in the script's AST</param>
/// <returns>A decision to stop searching if the right symbol was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
if (IsPositionInExtent(commandParameterAst.Extent))
{
FoundSymbolReference =
new SymbolReference(
SymbolType.Parameter,
commandParameterAst.Extent);
return(AstVisitAction.StopVisit);
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
Node expression = null;
if (commandParameterAst.Argument != null)
{
expression = VisitSyntaxNode(commandParameterAst.Argument);
}
_currentNode = new Argument(commandParameterAst.ParameterName, expression);
return(AstVisitAction.SkipChildren);
}
private Dictionary <string, string> GetParameters(ReadOnlyCollection <CommandElementAst> commandElements)
{
Dictionary <string, string> dictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
bool flag = false;
string key = null;
int num = 0;
foreach (CommandElementAst ast in commandElements)
{
if (!flag)
{
flag = true;
}
else
{
CommandParameterAst ast2 = ast as CommandParameterAst;
if (ast2 != null)
{
string parameterName = ast2.ParameterName;
if (ast2.Argument != null)
{
dictionary.Add(parameterName, ast2.Argument.ToString());
key = null;
}
else
{
key = parameterName;
}
}
else if (key != null)
{
ArrayExpressionAst ast3 = ast as ArrayExpressionAst;
if (ast3 != null)
{
dictionary.Add(key, ast3.SubExpression.ToString());
}
else
{
dictionary.Add(key, ast.ToString());
}
key = null;
}
else
{
dictionary.Add(num.ToString(CultureInfo.InvariantCulture), ast.ToString());
num++;
}
}
}
return(dictionary);
}
private static CommandParameterInternal GetCommandParameter(CommandParameterAst commandParameterAst, System.Management.Automation.ExecutionContext context)
{
ExpressionAst argument = commandParameterAst.Argument;
IScriptExtent errorPosition = commandParameterAst.ErrorPosition;
if (argument == null)
{
return(CommandParameterInternal.CreateParameter(errorPosition, commandParameterAst.ParameterName, errorPosition.Text));
}
object obj2 = Compiler.GetExpressionValue(argument, context, (IList)null);
bool spaceAfterParameter = (errorPosition.EndLineNumber != argument.Extent.StartLineNumber) || (errorPosition.EndColumnNumber != argument.Extent.StartColumnNumber);
return(CommandParameterInternal.CreateParameterWithArgument(errorPosition, commandParameterAst.ParameterName, errorPosition.Text, argument.Extent, obj2, spaceAfterParameter));
}
/// <summary>
/// Condition on the parameter that must be satisfied for the error to be raised.
/// </summary>
/// <param name="CmdAst"></param>
/// <param name="CeAst"></param>
/// <returns></returns>
public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst)
{
if (CeAst is CommandParameterAst)
{
CommandParameterAst cmdParamAst = CeAst as CommandParameterAst;
if (String.Equals(cmdParamAst.ParameterName, "computername", StringComparison.OrdinalIgnoreCase))
{
return(cmdParamAst.Argument is ConstantExpressionAst || GetComputerNameArg(CmdAst, cmdParamAst.Extent.StartOffset) is ConstantExpressionAst);
}
}
return(false);
}
public ParameterSet(CommandAst commandAst)
{
Validation.CheckArgument(commandAst, $"{nameof(commandAst)} cannot be null.");
var parameters = new List <Parameter>();
var elements = commandAst.CommandElements.Skip(1);
CommandParameterAst param = null;
Ast arg = null;
foreach (Ast elem in elements)
{
if (elem is CommandParameterAst p)
{
AddParameter(param, arg);
param = p;
arg = null;
}
else if (AzPredictorConstants.ParameterIndicator == elem?.ToString().Trim().FirstOrDefault())
{
// We have an incomplete command line such as
// `New-AzResourceGroup -Name ResourceGroup01 -Location WestUS -`
// We'll ignore the incomplete parameter.
AddParameter(param, arg);
param = null;
arg = null;
}
else
{
arg = elem;
}
}
Validation.CheckInvariant((param != null) || (arg == null));
AddParameter(param, arg);
Parameters = parameters;
void AddParameter(CommandParameterAst parameterName, Ast parameterValue)
{
if (parameterName != null)
{
parameters.Add(new Parameter(parameterName.ParameterName, (parameterValue == null) ? null : CommandLineUtilities.UnescapePredictionText(parameterValue.ToString())));
}
}
}
private void AddParameter(CommandParameterAst commandParameterAst)
{
string str;
object expressionValue;
if (commandParameterAst.Argument != null)
{
ExpressionAst argument = commandParameterAst.Argument;
IScriptExtent errorPosition = commandParameterAst.ErrorPosition;
str = ((errorPosition.EndLineNumber != argument.Extent.StartLineNumber) || (errorPosition.EndColumnNumber != argument.Extent.StartColumnNumber)) ? ": " : ":";
expressionValue = this.GetExpressionValue(commandParameterAst.Argument);
}
else
{
str = "";
expressionValue = null;
}
this._powershell.AddParameter(string.Format(CultureInfo.InvariantCulture, "-{0}{1}", new object[] { commandParameterAst.ParameterName, str }), expressionValue);
}
private IEnumerable <CorrectionExtent> GetCorrectionExtent(CommandParameterAst commandParameterAst, string correctlyCaseName)
{
var description = string.Format(
CultureInfo.CurrentCulture,
Strings.UseCorrectCasingDescription,
correctlyCaseName,
correctlyCaseName);
var cmdExtent = commandParameterAst.Extent;
var correction = new CorrectionExtent(
cmdExtent.StartLineNumber,
cmdExtent.EndLineNumber,
// +1 because of the dash before the parameter name
cmdExtent.StartColumnNumber + 1,
// do not use EndColumnNumber property as it would not cover the case where the colon syntax: -ParameterName:$ParameterValue
cmdExtent.StartColumnNumber + 1 + commandParameterAst.ParameterName.Length,
correctlyCaseName,
commandParameterAst.Extent.File,
description);
yield return(correction);
}
private string GetDslInstanceName(string dslTypeName, IEnumerable <CommandElementAst> commandElements)
{
// try to guess dsl instance name - first string constant that is not named parameter value (or is value of 'name' parameter)
bool lastElementIsUnknownParameter = false;
int num = 0;
foreach (CommandElementAst elementAst in commandElements)
{
if (num++ == 0)
{
continue;
}
if (elementAst is CommandParameterAst)
{
CommandParameterAst commandParameterAst = (CommandParameterAst)elementAst;
lastElementIsUnknownParameter = commandParameterAst.ParameterName.ToLowerInvariant() != "name";
if (dslTypeName.StartsWith("PSDesiredStateConfiguration") && !lastElementIsUnknownParameter)
{
return(commandParameterAst.Argument.ToString());
}
continue;
}
if (elementAst is StringConstantExpressionAst && !lastElementIsUnknownParameter)
{
return(((StringConstantExpressionAst)elementAst).Value);
}
if (elementAst is ExpandableStringExpressionAst && !lastElementIsUnknownParameter)
{
return(((ExpandableStringExpressionAst)elementAst).Value);
}
if (elementAst is MemberExpressionAst && !lastElementIsUnknownParameter)
{
return(((MemberExpressionAst)elementAst).Extent.Text);
}
lastElementIsUnknownParameter = false;
}
return(string.Empty);
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
object newParentObject;
var commandElements = commandAst.CommandElements;
string dslInstanceName = this.DslNameGiver(commandElements, commandAst.Parent);
if (dslInstanceName == null)
{
return(AstVisitAction.Continue);
}
string dslTypeName = ((StringConstantExpressionAst)commandElements[0]).Value;
dslTypeName = dslTypeName.Replace("PSDesiredStateConfiguration\\", "");
if (dslTypeName.ToLowerInvariant() == "configuration")
{
CommandParameterAst nameAst = (CommandParameterAst)commandAst.Find(ast => ast is CommandParameterAst && "name".Equals(((CommandParameterAst)ast).ParameterName.ToLowerInvariant()), false);
newParentObject = this.ConfigurationAction(nameAst.Argument.ToString(), commandAst.Extent, this.GetCurrentNestingLevel(), this.GetCurrentParentObject());
}
else
{
newParentObject = this.DslAction(dslTypeName, dslInstanceName, commandAst.Extent, this.GetCurrentNestingLevel(), this.GetCurrentParentObject());
}
Ast body = commandAst.Find(ast => ast is CommandParameterAst && ("body".Equals(((CommandParameterAst)ast).ParameterName.ToLowerInvariant()) ||
"value".Equals(((CommandParameterAst)ast).ParameterName.ToLowerInvariant())), false);
if (body != null)
{
this.VisitChildren(body, newParentObject);
}
else
{
this.VisitChildren(commandElements[commandElements.Count - 1], newParentObject);
}
return(AstVisitAction.SkipChildren);
}
public object VisitCommandParameter(CommandParameterAst commandParameterAst)
{
return(false);
}
/// <summary>
/// Select the command argument that the cursor is at, or the previous/next Nth command arguments from the current cursor position.
/// </summary>
public static void SelectCommandArgument(ConsoleKeyInfo?key = null, object arg = null)
{
if (!TryGetArgAsInt(arg, out var numericArg, 0))
{
return;
}
_singleton.MaybeParseInput();
int cursor = _singleton._current;
int prev = -1, curr = -1, next = -1;
var sbAsts = _singleton._ast.FindAll(GetScriptBlockAst, searchNestedScriptBlocks: true).ToList();
var arguments = new List <ExpressionAst>();
// We start searching for command arguments from the most nested script block.
for (int i = sbAsts.Count - 1; i >= 0; i--)
{
var sbAst = sbAsts[i];
var cmdAsts = sbAst.FindAll(ast => ast is CommandAst, searchNestedScriptBlocks: false);
foreach (CommandAst cmdAst in cmdAsts)
{
for (int j = 1; j < cmdAst.CommandElements.Count; j++)
{
var argument = cmdAst.CommandElements[j] switch
{
CommandParameterAst paramAst => paramAst.Argument,
ExpressionAst expAst => expAst,
_ => null,
};
if (argument is not null)
{
arguments.Add(argument);
int start = argument.Extent.StartOffset;
int end = argument.Extent.EndOffset;
if (end <= cursor)
{
prev = arguments.Count - 1;
}
if (curr == -1 && start <= cursor && end > cursor)
{
curr = arguments.Count - 1;
}
else if (next == -1 && start > cursor)
{
next = arguments.Count - 1;
}
}
}
}
// Stop searching the outer script blocks if we find any command arguments within the current script block.
if (arguments.Count > 0)
{
break;
}
}
// Simply return if we didn't find any command arguments.
int count = arguments.Count;
if (count == 0)
{
return;
}
if (prev == -1)
{
prev = count - 1;
}
if (next == -1)
{
next = 0;
}
if (curr == -1)
{
curr = numericArg > 0 ? prev : next;
}
int newStartCursor, newEndCursor;
int selectCount = _singleton._visualSelectionCommandCount;
// When an argument is already visually selected by the previous run of this function, the cursor would have past the selected argument.
// In this case, if a user wants to move backward to an argument that is before the currently selected argument by having numericArg < 0,
// we will need to adjust 'numericArg' to move to the expected argument.
// Scenario:
// 1) 'Alt+a' to select an argument;
// 2) 'Alt+-' to make 'numericArg = -1';
// 3) 'Alt+a' to select the argument that is right before the currently selected argument.
if (count > 1 && numericArg < 0 && curr == next && selectCount > 0)
{
var prevArg = arguments[prev];
if (_singleton._mark == prevArg.Extent.StartOffset && cursor == prevArg.Extent.EndOffset)
{
numericArg--;
}
}
while (true)
{
ExpressionAst targetAst = null;
if (numericArg == 0)
{
targetAst = arguments[curr];
}
else
{
int index = curr + numericArg;
index = index >= 0 ? index % count : (count + index % count) % count;
targetAst = arguments[index];
}
// Handle quoted-string arguments specially, by leaving the quotes out of the visual selection.
StringConstantType?constantType = null;
if (targetAst is StringConstantExpressionAst conString)
{
constantType = conString.StringConstantType;
}
else if (targetAst is ExpandableStringExpressionAst expString)
{
constantType = expString.StringConstantType;
}
int startOffsetAdjustment = 0, endOffsetAdjustment = 0;
switch (constantType)
{
case StringConstantType.DoubleQuoted:
case StringConstantType.SingleQuoted:
startOffsetAdjustment = endOffsetAdjustment = 1;
break;
case StringConstantType.DoubleQuotedHereString:
case StringConstantType.SingleQuotedHereString:
startOffsetAdjustment = 2;
endOffsetAdjustment = 3;
break;
default: break;
}
newStartCursor = targetAst.Extent.StartOffset + startOffsetAdjustment;
newEndCursor = targetAst.Extent.EndOffset - endOffsetAdjustment;
// For quoted-string arguments, due to the special handling above, the cursor would always be
// within the selected argument (cursor is placed at the ending quote), and thus when running
// the 'SelectCommandArgument' action again, the same argument would be chosen.
//
// Below is how we detect this and move to the next argument when there is one:
// * the previous action was a visual selection command and the visual range was exactly
// what we are going to make. AND
// * count > 1, meaning that there are other arguments. AND
// * numericArg == 0. When 'numericArg' is not 0, the user is leaping among the available
// arguments, so it's possible that the same argument gets chosen.
// In this case, we should select the next argument.
if (numericArg == 0 && count > 1 && selectCount > 0 &&
_singleton._mark == newStartCursor && cursor == newEndCursor)
{
curr = next;
continue;
}
break;
}
// Move cursor to the start of the argument.
SetCursorPosition(newStartCursor);
// Make the intended range visually selected.
_singleton.VisualSelectionCommon(() => SetCursorPosition(newEndCursor), forceSetMark: true);
// Get the script block AST's whose extent contains the cursor.
bool GetScriptBlockAst(Ast ast)
{
if (ast is not ScriptBlockAst)
{
return(false);
}
if (ast.Parent is null)
{
return(true);
}
if (ast.Extent.StartOffset >= cursor)
{
return(false);
}
// If the script block is closed, then we want the script block only if the cursor is within the script block.
// Otherwise, if the script block is not completed, then we want the script block even if the cursor is at the end.
int textLength = ast.Extent.Text.Length;
return(ast.Extent.Text[textLength - 1] == '}'
? ast.Extent.EndOffset - 1 > cursor
: ast.Extent.EndOffset >= cursor);
}
}
/// <summary>
/// Return true if mandatory parameters are used OR the cmdlet does not exist
/// </summary>
/// <param name="cmdAst"></param>
/// <returns></returns>
private bool MandatoryParameterExists(CommandAst cmdAst)
{
CommandInfo cmdInfo = null;
List <ParameterMetadata> mandParams = new List <ParameterMetadata>();
IEnumerable <CommandElementAst> ceAsts = null;
bool returnValue = false;
#region Predicates
// Predicate to find ParameterAsts.
Func <CommandElementAst, bool> foundParamASTs = delegate(CommandElementAst ceAst)
{
if (ceAst is CommandParameterAst)
{
return(true);
}
return(false);
};
#endregion
#region Compares parameter list and mandatory parameter list.
cmdInfo = Helper.Instance.GetCommandInfo(cmdAst.GetCommandName());
if (cmdInfo == null || (cmdInfo.CommandType != System.Management.Automation.CommandTypes.Cmdlet))
{
return(true);
}
// ignores if splatted variable is used
if (Helper.Instance.HasSplattedVariable(cmdAst))
{
return(true);
}
// Gets parameters from command elements.
ceAsts = cmdAst.CommandElements.Where <CommandElementAst>(foundParamASTs);
// Gets mandatory parameters from cmdlet.
// If cannot find any mandatory parameter, it's not necessary to do a further check for current cmdlet.
try
{
int noOfParamSets = cmdInfo.ParameterSets.Count;
foreach (ParameterMetadata pm in cmdInfo.Parameters.Values)
{
int count = 0;
if (pm.Attributes.Count < noOfParamSets)
{
continue;
}
foreach (Attribute attr in pm.Attributes)
{
if (!(attr is ParameterAttribute))
{
continue;
}
if (((ParameterAttribute)attr).Mandatory)
{
count += 1;
}
}
if (count >= noOfParamSets)
{
mandParams.Add(pm);
}
}
}
catch (Exception)
{
// For cases like cmd.exe. Also for runtime exception
return(true);
}
if (mandParams.Count() == 0 || Helper.Instance.PositionalParameterUsed(cmdAst))
{
returnValue = true;
}
else
{
// Compares parameter list and mandatory parameter list.
foreach (CommandElementAst ceAst in ceAsts)
{
CommandParameterAst cpAst = (CommandParameterAst)ceAst;
if (mandParams.Count <ParameterMetadata>(item =>
item.Name.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)) > 0)
{
returnValue = true;
break;
}
}
}
#endregion
return(returnValue);
}
public override object VisitCommandParameter(CommandParameterAst commandParameterAst)
{
script_.Write("-" + commandParameterAst.ParameterName);
VisitElement(commandParameterAst.Argument);
return(commandParameterAst);
}
public override AstVisitAction VisitCommandParameter(CommandParameterAst commandParameterAst)
{
Console.WriteLine("Visited an CommandParameterAst.");
Console.WriteLine(" " + commandParameterAst.ToString().Replace(Environment.NewLine, Environment.NewLine + " "));
return(AstVisitAction.Continue);
}
public object VisitCommandParameter(CommandParameterAst commandParameterAst)
{
Console.WriteLine("Visited an CommandParameterAst.");
return(commandParameterAst);
}
