public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
throw new UnexpectedElementException();
}
private List <CompletionResult> GetResultForIdentifier(CompletionContext completionContext, ref int replacementIndex, ref int replacementLength, bool isQuotedString)
{
Token tokenAtCursor = completionContext.TokenAtCursor;
Ast lastAst = completionContext.RelatedAsts.Last <Ast>();
List <CompletionResult> source = null;
completionContext.WordToComplete = tokenAtCursor.Text;
StringConstantExpressionAst ast2 = lastAst as StringConstantExpressionAst;
if ((ast2 != null) && ast2.Value.Equals("$", StringComparison.Ordinal))
{
completionContext.WordToComplete = "";
return(CompletionCompleters.CompleteVariable(completionContext));
}
if ((tokenAtCursor.TokenFlags & TokenFlags.CommandName) != TokenFlags.None)
{
if ((completionContext.RelatedAsts.Count > 0) && (completionContext.RelatedAsts[0] is ScriptBlockAst))
{
Ast lastAstAtCursor = null;
InternalScriptPosition position = (InternalScriptPosition)this._cursorPosition;
int offset = position.Offset - tokenAtCursor.Text.Length;
if (offset >= 0)
{
InternalScriptPosition cursorPosition = position.CloneWithNewOffset(offset);
ScriptBlockAst scriptBlockAst = (ScriptBlockAst)completionContext.RelatedAsts[0];
lastAstAtCursor = GetLastAstAtCursor(scriptBlockAst, cursorPosition);
}
if (((lastAstAtCursor != null) && (lastAstAtCursor.Extent.EndLineNumber == tokenAtCursor.Extent.StartLineNumber)) && (lastAstAtCursor.Extent.EndColumnNumber == tokenAtCursor.Extent.StartColumnNumber))
{
if (tokenAtCursor.Text.IndexOfAny(new char[] { '\\', '/' }) == 0)
{
string str = CompletionCompleters.ConcatenateStringPathArguments(lastAstAtCursor as CommandElementAst, tokenAtCursor.Text, completionContext);
if (str != null)
{
completionContext.WordToComplete = str;
source = new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext));
if (source.Count > 0)
{
replacementIndex = lastAstAtCursor.Extent.StartScriptPosition.Offset;
replacementLength += lastAstAtCursor.Extent.Text.Length;
}
return(source);
}
VariableExpressionAst variableAst = lastAstAtCursor as VariableExpressionAst;
string str2 = (variableAst != null) ? CompletionCompleters.CombineVariableWithPartialPath(variableAst, tokenAtCursor.Text, completionContext.ExecutionContext) : null;
if (str2 == null)
{
return(source);
}
completionContext.WordToComplete = str2;
replacementIndex = lastAstAtCursor.Extent.StartScriptPosition.Offset;
replacementLength += lastAstAtCursor.Extent.Text.Length;
completionContext.ReplacementIndex = replacementIndex;
completionContext.ReplacementLength = replacementLength;
}
else if (!(lastAstAtCursor is ErrorExpressionAst) || !(lastAstAtCursor.Parent is IndexExpressionAst))
{
return(source);
}
}
}
if (!isQuotedString)
{
StringExpandableToken token2 = tokenAtCursor as StringExpandableToken;
if (((token2 != null) && (token2.NestedTokens != null)) && (ast2 != null))
{
try
{
string expandedString = null;
ExpandableStringExpressionAst expandableStringAst = new ExpandableStringExpressionAst(ast2.Extent, ast2.Value, StringConstantType.BareWord);
if (CompletionCompleters.IsPathSafelyExpandable(expandableStringAst, string.Empty, completionContext.ExecutionContext, out expandedString))
{
completionContext.WordToComplete = expandedString;
}
else
{
return(source);
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
return(source);
}
}
source = CompleteFileNameAsCommand(completionContext);
List <CompletionResult> collection = CompletionCompleters.CompleteCommand(completionContext);
if ((collection != null) && (collection.Count > 0))
{
source.AddRange(collection);
}
}
return(source);
}
if (((tokenAtCursor.Text.Length == 1) && tokenAtCursor.Text[0].IsDash()) && (lastAst.Parent is CommandAst))
{
if (isQuotedString)
{
return(source);
}
return(CompletionCompleters.CompleteCommandParameter(completionContext));
}
TokenKind unknown = TokenKind.Unknown;
bool flag = lastAst.Parent is MemberExpressionAst;
bool @static = flag ? ((MemberExpressionAst)lastAst.Parent).Static : false;
bool flag3 = false;
if (!flag)
{
if (tokenAtCursor.Text.Equals(TokenKind.Dot.Text(), StringComparison.Ordinal))
{
unknown = TokenKind.Dot;
flag = true;
}
else if (tokenAtCursor.Text.Equals(TokenKind.ColonColon.Text(), StringComparison.Ordinal))
{
unknown = TokenKind.ColonColon;
flag = true;
}
else if (tokenAtCursor.Kind.Equals(TokenKind.Multiply) && (lastAst is BinaryExpressionAst))
{
BinaryExpressionAst item = (BinaryExpressionAst)lastAst;
MemberExpressionAst left = item.Left as MemberExpressionAst;
IScriptExtent errorPosition = item.ErrorPosition;
if (((left != null) && (item.Operator == TokenKind.Multiply)) && (errorPosition.StartOffset == left.Member.Extent.EndOffset))
{
@static = left.Static;
unknown = @static ? TokenKind.ColonColon : TokenKind.Dot;
flag = true;
flag3 = true;
completionContext.RelatedAsts.Remove(item);
completionContext.RelatedAsts.Add(left);
StringConstantExpressionAst member = left.Member as StringConstantExpressionAst;
if (member != null)
{
replacementIndex = member.Extent.StartScriptPosition.Offset;
replacementLength += member.Extent.Text.Length;
}
}
}
}
if (flag)
{
source = CompletionCompleters.CompleteMember(completionContext, @static || (unknown == TokenKind.ColonColon));
if (source.Any <CompletionResult>())
{
if (!flag3 && (unknown != TokenKind.Unknown))
{
replacementIndex += tokenAtCursor.Text.Length;
replacementLength = 0;
}
return(source);
}
}
if (lastAst.Parent is HashtableAst)
{
source = CompletionCompleters.CompleteHashtableKey(completionContext, (HashtableAst)lastAst.Parent);
if ((source != null) && source.Any <CompletionResult>())
{
return(source);
}
}
if (!isQuotedString)
{
bool flag4 = false;
if ((lastAst.Parent is FileRedirectionAst) || CompleteAgainstSwitchFile(lastAst, completionContext.TokenBeforeCursor))
{
string str4 = CompletionCompleters.ConcatenateStringPathArguments(lastAst as CommandElementAst, string.Empty, completionContext);
if (str4 != null)
{
flag4 = true;
completionContext.WordToComplete = str4;
}
}
else if (tokenAtCursor.Text.IndexOfAny(new char[] { '\\', '/' }) == 0)
{
CommandBaseAst parent = lastAst.Parent as CommandBaseAst;
if ((parent != null) && parent.Redirections.Any <RedirectionAst>())
{
FileRedirectionAst ast11 = parent.Redirections[0] as FileRedirectionAst;
if (((ast11 != null) && (ast11.Extent.EndLineNumber == lastAst.Extent.StartLineNumber)) && (ast11.Extent.EndColumnNumber == lastAst.Extent.StartColumnNumber))
{
string str5 = CompletionCompleters.ConcatenateStringPathArguments(ast11.Location, tokenAtCursor.Text, completionContext);
if (str5 != null)
{
flag4 = true;
completionContext.WordToComplete = str5;
replacementIndex = ast11.Location.Extent.StartScriptPosition.Offset;
replacementLength += ast11.Location.Extent.EndScriptPosition.Offset - replacementIndex;
completionContext.ReplacementIndex = replacementIndex;
completionContext.ReplacementLength = replacementLength;
}
}
}
}
if (flag4)
{
return(new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext)));
}
string str6 = CompletionCompleters.ConcatenateStringPathArguments(lastAst as CommandElementAst, string.Empty, completionContext);
if (str6 != null)
{
completionContext.WordToComplete = str6;
}
source = CompletionCompleters.CompleteCommandArgument(completionContext);
replacementIndex = completionContext.ReplacementIndex;
replacementLength = completionContext.ReplacementLength;
}
return(source);
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
var explanation = new Explanation
{
CommandName = "Variable",
HelpResult = HelpTableQuery("about_variables"),
}.AddDefaults(variableExpressionAst, explanations);
var prefix = " ";
var suffix = "";
var varName = variableExpressionAst.VariablePath.UserPath;
var standard = $"named '{varName}'";
if (HasSpecialVars(varName))
{
if (string.Equals(varName, SpecialVars.PSDefaultParameterValues, StringComparison.OrdinalIgnoreCase))
{
suffix = ", a special variable to set parameter default values.";
explanation.CommandName = "PSDefaultParameterValues";
explanation.HelpResult = HelpTableQuery("about_Parameters_Default_Values");
}
else if (SpecialVars.AutomaticVariables.Contains(varName, StringComparer.OrdinalIgnoreCase))
{
suffix = ", an automatic variable.";
explanation.CommandName = "Automatic variable";
explanation.HelpResult = HelpTableQuery("about_automatic_variables");
}
else if (SpecialVars.PreferenceVariables.Contains(varName, StringComparer.OrdinalIgnoreCase))
{
suffix = ", a preference variable.";
explanation.CommandName = "Preference variable";
explanation.HelpResult = HelpTableQuery("about_Preference_variables");
}
else
{
suffix = ", a special variable.";
explanation.CommandName = "Special variable";
explanation.HelpResult = HelpTableQuery("about_automatic_variables");
}
}
if (varName == "_" | string.Equals(varName, "PSItem", StringComparison.OrdinalIgnoreCase))
{
suffix = ", a built-in variable that holds the current element from the objects being passed in from the pipeline.";
explanation.CommandName = "Pipeline iterator variable";
explanation.HelpResult = HelpTableQuery("about_automatic_variables");
}
if (variableExpressionAst.Splatted)
{
prefix = " splatted ";
explanation.CommandName = "Splatted variable";
explanation.HelpResult = HelpTableQuery("about_splatting");
}
if (variableExpressionAst.VariablePath.IsPrivate)
{
prefix = $" private ";
}
if (!variableExpressionAst.VariablePath.IsUnscopedVariable)
{
var split = variableExpressionAst
.VariablePath
.UserPath
.Split(':');
var identifier = split.FirstOrDefault();
varName = split.LastOrDefault();
standard = $"named '{varName}'";
if (variableExpressionAst.VariablePath.IsGlobal | variableExpressionAst.VariablePath.IsScript)
{
suffix = $" in '{identifier}' scope ";
explanation.CommandName = "Scoped variable";
explanation.HelpResult = HelpTableQuery("about_scopes");
}
if (variableExpressionAst.VariablePath.IsDriveQualified)
{
if (string.Equals(identifier, "Env", StringComparison.OrdinalIgnoreCase))
{
prefix = "n environment ";
suffix = " (on PSDrive 'env:')";
explanation.CommandName = "Environment variable";
explanation.HelpResult = HelpTableQuery("about_Environment_Variables");
}
else
{
standard = $"pointing to item '{varName}'";
suffix = $" on PSDrive '{identifier}:'";
explanation.CommandName = "PSDrive (Providers)";
explanation.HelpResult = HelpTableQuery("about_Providers");
}
}
}
if (variableExpressionAst.Parent is UsingExpressionAst)
{
suffix = ", with the 'using' scope modifier: a local variable used in a remote scope.";
explanation.HelpResult = HelpTableQuery("about_Remote_Variables");
explanation.CommandName = "Scoped variable";
explanation.HelpResult.RelatedLinks += HelpTableQuery("about_Scopes")?.DocumentationLink;
}
explanation.Description = $"A{prefix}variable {standard}{suffix}";
explanations.Add(explanation);
return(AstVisitAction.SkipChildren);
}
private static bool ThrowStrictModeUndefinedVariable(ExecutionContext executionContext, VariableExpressionAst varAst)
{
// In some limited cases, the compiler knows we don't want an error, like when we're backing up
// $foreach and $switch, which might not be set. In that case, the ast passed is null.
if (varAst == null)
{
return(false);
}
if (executionContext.IsStrictVersion(2))
{
return(true);
}
if (executionContext.IsStrictVersion(1))
{
var parent = varAst.Parent;
while (parent != null)
{
if (parent is ExpandableStringExpressionAst)
{
return(false);
}
parent = parent.Parent;
}
return(true);
}
return(false);
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
Console.WriteLine("Visited an VariableExpressionAst.");
return(variableExpressionAst);
}
/// <summary/> public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) => DefaultVisit(variableExpressionAst);
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(variableExpressionAst.Copy());
}
/// <summary>
/// Gets a variable <see cref="Expression" /> from the current or a parent scope.
/// </summary>
/// <param name="variableExpressionAst">
/// The <see cref="VariableExpressionAst" /> to obtain a variable <see cref="Expression" /> for.
/// </param>
/// <param name="alreadyDefined">
/// A value indicating whether the variable has already been defined.
/// </param>
/// <returns>The resolved variable <see cref="Expression" />.</returns>
internal ParameterExpression GetVariable(
VariableExpressionAst variableExpressionAst,
out bool alreadyDefined)
{
return(_current.GetOrCreateVariable(variableExpressionAst.VariablePath.UserPath, variableExpressionAst.StaticType, out alreadyDefined));
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast)
{
return(AstVisitAction.Continue);
}
private void ConvertCommand(CommandAst commandAst)
{
Command command = new Command(this.GetCommandName(commandAst.CommandElements[0]), false, this._createLocalScope);
if (commandAst.Redirections.Count > 0)
{
PipelineResultTypes all;
PipelineResultTypes output = PipelineResultTypes.Output;
switch (commandAst.Redirections[0].FromStream)
{
case RedirectionStream.All:
all = PipelineResultTypes.All;
break;
case RedirectionStream.Error:
all = PipelineResultTypes.Error;
break;
case RedirectionStream.Warning:
all = PipelineResultTypes.Warning;
break;
case RedirectionStream.Verbose:
all = PipelineResultTypes.Verbose;
break;
case RedirectionStream.Debug:
all = PipelineResultTypes.Debug;
break;
default:
all = PipelineResultTypes.Error;
break;
}
command.MergeMyResults(all, output);
}
this._powershell.AddCommand(command);
foreach (CommandElementAst ast in commandAst.CommandElements.Skip <CommandElementAst>(1))
{
ExpressionAst exprAst = ast as ExpressionAst;
if (exprAst != null)
{
VariableExpressionAst variableAst = null;
UsingExpressionAst ast4 = ast as UsingExpressionAst;
if (ast4 != null)
{
variableAst = ast4.SubExpression as VariableExpressionAst;
if ((variableAst != null) && variableAst.Splatted)
{
IDictionary parameters = this._usingValues[ast4.RuntimeUsingIndex] as IDictionary;
if (parameters != null)
{
this._powershell.AddParameters(parameters);
}
else
{
IEnumerable enumerable = this._usingValues[ast4.RuntimeUsingIndex] as IEnumerable;
if (enumerable != null)
{
foreach (object obj2 in enumerable)
{
this._powershell.AddArgument(obj2);
}
}
else
{
this._powershell.AddArgument(this._usingValues[ast4.RuntimeUsingIndex]);
}
}
}
else
{
this._powershell.AddArgument(this._usingValues[ast4.RuntimeUsingIndex]);
}
}
else
{
variableAst = ast as VariableExpressionAst;
if ((variableAst != null) && variableAst.Splatted)
{
this.GetSplattedVariable(variableAst);
}
else
{
object expressionValue;
ConstantExpressionAst ast5 = ast as ConstantExpressionAst;
if ((ast5 != null) && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(ast5.StaticType)))
{
string text = ast5.Extent.Text;
expressionValue = ast5.Value;
if (!text.Equals(ast5.Value.ToString(), StringComparison.Ordinal))
{
expressionValue = ParserOps.WrappedNumber(expressionValue, text);
}
}
else
{
expressionValue = this.GetExpressionValue(exprAst);
}
this._powershell.AddArgument(expressionValue);
}
}
}
else
{
this.AddParameter((CommandParameterAst)ast);
}
}
}
private static object[] GetUsingValues(Ast body, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables)
{
List <Ast> list = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList <Ast>();
object[] objArray = new object[list.Count];
HashSet <string> set = ((variables != null) && filterNonUsingVariables) ? new HashSet <string>() : null;
UsingExpressionAst usingExpr = null;
Version strictModeVersion = null;
try
{
if (context != null)
{
strictModeVersion = context.EngineSessionState.CurrentScope.StrictModeVersion;
context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion;
}
for (int i = 0; i < objArray.Length; i++)
{
usingExpr = (UsingExpressionAst)list[i];
if (IsUsingExpressionInFunction(usingExpr, body))
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableNotSupportedInFunctionOrFilter", AutomationExceptions.UsingVariableNotSupportedInFunctionOrFilter, new object[] { usingExpr });
}
object obj2 = null;
if (variables != null)
{
VariableExpressionAst subExpression = usingExpr.SubExpression as VariableExpressionAst;
if (subExpression == null)
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, new object[] { usingExpr.Extent.Text });
}
string userPath = subExpression.VariablePath.UserPath;
if (((userPath != null) && variables.TryGetValue(userPath, out obj2)) && (set != null))
{
set.Add(userPath);
}
}
else
{
obj2 = Compiler.GetExpressionValue(usingExpr.SubExpression, context, (IList)null);
}
objArray[i] = obj2;
usingExpr.RuntimeUsingIndex = i;
}
}
catch (RuntimeException exception)
{
if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal))
{
throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, new object[] { exception.ErrorRecord.TargetObject });
}
if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("UsingVariableNotSupportedInFunctionOrFilter", StringComparison.Ordinal) || exception.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal))
{
throw;
}
}
finally
{
if (context != null)
{
context.EngineSessionState.CurrentScope.StrictModeVersion = strictModeVersion;
}
}
if (set != null)
{
foreach (string str2 in variables.Keys.ToArray <string>())
{
if (!set.Contains(str2))
{
variables.Remove(str2);
}
}
}
return(objArray);
}
/// <summary>
/// Checks if a variable is initialized and referenced in either its assignment or children scopes
/// </summary>
/// <param name="scriptBlockAst">Ast of type ScriptBlock</param>
/// <param name="fileName">Name of file containing the ast</param>
/// <returns>An enumerable containing diagnostic records</returns>
private IEnumerable <DiagnosticRecord> AnalyzeScriptBlockAst(ScriptBlockAst scriptBlockAst, string fileName)
{
IEnumerable <Ast> assignmentAsts = scriptBlockAst.FindAll(testAst => testAst is AssignmentStatementAst, false);
IEnumerable <Ast> varAsts = scriptBlockAst.FindAll(testAst => testAst is VariableExpressionAst, true);
IEnumerable <Ast> varsInAssignment;
Dictionary <string, AssignmentStatementAst> assignmentsDictionary_OrdinalIgnoreCase = new Dictionary <string, AssignmentStatementAst>(StringComparer.OrdinalIgnoreCase);
string varKey;
bool inAssignment;
if (assignmentAsts == null)
{
yield break;
}
foreach (AssignmentStatementAst assignmentAst in assignmentAsts)
{
// Only checks for the case where lhs is a variable. Ignore things like $foo.property
VariableExpressionAst assignmentVarAst = assignmentAst.Left as VariableExpressionAst;
if (assignmentVarAst == null)
{
// If the variable is declared in a strongly typed way, e.g. [string]$s = 'foo' then the type is ConvertExpressionAst.
// Therefore we need to the VariableExpressionAst from its Child property.
var assignmentVarAstAsConvertExpressionAst = assignmentAst.Left as ConvertExpressionAst;
if (assignmentVarAstAsConvertExpressionAst != null && assignmentVarAstAsConvertExpressionAst.Child != null)
{
assignmentVarAst = assignmentVarAstAsConvertExpressionAst.Child as VariableExpressionAst;
}
}
if (assignmentVarAst != null)
{
// Ignore if variable is global or environment variable or scope is drive qualified variable
if (!Helper.Instance.IsVariableGlobalOrEnvironment(assignmentVarAst, scriptBlockAst) &&
!assignmentVarAst.VariablePath.IsScript &&
assignmentVarAst.VariablePath.DriveName == null)
{
string variableName = Helper.Instance.VariableNameWithoutScope(assignmentVarAst.VariablePath);
if (!assignmentsDictionary_OrdinalIgnoreCase.ContainsKey(variableName))
{
assignmentsDictionary_OrdinalIgnoreCase.Add(variableName, assignmentAst);
}
}
}
}
if (varAsts != null)
{
foreach (VariableExpressionAst varAst in varAsts)
{
varKey = Helper.Instance.VariableNameWithoutScope(varAst.VariablePath);
inAssignment = false;
if (assignmentsDictionary_OrdinalIgnoreCase.ContainsKey(varKey))
{
varsInAssignment = assignmentsDictionary_OrdinalIgnoreCase[varKey].Left.FindAll(testAst => testAst is VariableExpressionAst, true);
// Checks if this variableAst is part of the logged assignment
foreach (VariableExpressionAst varInAssignment in varsInAssignment)
{
// Try casting to AssignmentStatementAst to be able to catch case where a variable is assigned more than once (https://github.com/PowerShell/PSScriptAnalyzer/issues/833)
var varInAssignmentAsStatementAst = varInAssignment.Parent as AssignmentStatementAst;
var varAstAsAssignmentStatementAst = varAst.Parent as AssignmentStatementAst;
if (varAstAsAssignmentStatementAst != null)
{
if (varAstAsAssignmentStatementAst.Operator == TokenKind.Equals)
{
if (varInAssignmentAsStatementAst != null)
{
inAssignment = varInAssignmentAsStatementAst.Left.Extent.Text.Equals(varAstAsAssignmentStatementAst.Left.Extent.Text, StringComparison.OrdinalIgnoreCase);
}
else
{
inAssignment = varInAssignment.Equals(varAst);
}
}
}
else
{
inAssignment = varInAssignment.Equals(varAst);
}
}
if (!inAssignment)
{
assignmentsDictionary_OrdinalIgnoreCase.Remove(varKey);
}
// Check if variable belongs to PowerShell built-in variables
if (Helper.Instance.HasSpecialVars(varKey))
{
assignmentsDictionary_OrdinalIgnoreCase.Remove(varKey);
}
}
}
}
// Detect usages of Get-Variable
var getVariableCmdletNamesAndAliases = Helper.Instance.CmdletNameAndAliases("Get-Variable");
IEnumerable <Ast> getVariableCommandAsts = scriptBlockAst.FindAll(testAst => testAst is CommandAst commandAst &&
getVariableCmdletNamesAndAliases.Contains(commandAst.GetCommandName(), StringComparer.OrdinalIgnoreCase), true);
foreach (CommandAst getVariableCommandAst in getVariableCommandAsts)
{
var commandElements = getVariableCommandAst.CommandElements.ToList();
// The following extracts the variable name only in the simplest possibe case 'Get-Variable variableName'
if (commandElements.Count == 2 && commandElements[1] is StringConstantExpressionAst constantExpressionAst)
{
var variableName = constantExpressionAst.Value;
if (assignmentsDictionary_OrdinalIgnoreCase.ContainsKey(variableName))
{
assignmentsDictionary_OrdinalIgnoreCase.Remove(variableName);
}
}
}
foreach (string key in assignmentsDictionary_OrdinalIgnoreCase.Keys)
{
yield return(new DiagnosticRecord(
string.Format(CultureInfo.CurrentCulture, Strings.UseDeclaredVarsMoreThanAssignmentsError, key),
assignmentsDictionary_OrdinalIgnoreCase[key].Left.Extent,
GetName(),
DiagnosticSeverity.Warning,
fileName,
key));
}
}
private static object GetAutomaticVariableValue(int tupleIndex, ExecutionContext executionContext, VariableExpressionAst varAst)
{
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableRead(SpecialVariables.AutomaticVariables[tupleIndex]);
}
object automaticVariableValue = executionContext.EngineSessionState.GetAutomaticVariableValue((AutomaticVariable)tupleIndex);
if (automaticVariableValue != AutomationNull.Value)
{
return(automaticVariableValue);
}
if (ThrowStrictModeUndefinedVariable(executionContext, varAst))
{
throw InterpreterError.NewInterpreterException(SpecialVariables.AutomaticVariables[tupleIndex], typeof(RuntimeException), varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, new object[] { SpecialVariables.AutomaticVariables[tupleIndex] });
}
return(null);
}
private static bool ThrowStrictModeUndefinedVariable(ExecutionContext executionContext, VariableExpressionAst varAst)
{
if (varAst == null)
{
return(false);
}
if (!executionContext.IsStrictVersion(2))
{
if (!executionContext.IsStrictVersion(1))
{
return(false);
}
for (Ast ast = varAst.Parent; ast != null; ast = ast.Parent)
{
if (ast is ExpandableStringExpressionAst)
{
return(false);
}
}
}
return(true);
}
private PSVariable GetVariable(VariableExpressionAst variableExpressionAst)
{
var variable = this._context.SessionState.PSVariable.Get(variableExpressionAst.VariablePath.UserPath);
return(variable);
}
public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(variableExpressionAst);
}
private void ConvertCommand(CommandAst commandAst, bool isTrustedInput)
{
// First need command name.
var commandName = GetCommandName(commandAst.CommandElements[0], isTrustedInput);
var command = new Command(commandName, isScript: false, useLocalScope: _createLocalScope);
// Handle redirections, if any (there can really be just 0 or 1).
if (commandAst.Redirections.Count > 0)
{
Diagnostics.Assert(commandAst.Redirections.Count == 1, "only 1 kind of redirection is supported");
Diagnostics.Assert(commandAst.Redirections[0] is MergingRedirectionAst, "unexpected redirection type");
PipelineResultTypes toType = PipelineResultTypes.Output;
PipelineResultTypes fromType;
switch (commandAst.Redirections[0].FromStream)
{
case RedirectionStream.Error:
fromType = PipelineResultTypes.Error;
break;
case RedirectionStream.Warning:
fromType = PipelineResultTypes.Warning;
break;
case RedirectionStream.Verbose:
fromType = PipelineResultTypes.Verbose;
break;
case RedirectionStream.Debug:
fromType = PipelineResultTypes.Debug;
break;
case RedirectionStream.Information:
fromType = PipelineResultTypes.Information;
break;
case RedirectionStream.All:
fromType = PipelineResultTypes.All;
break;
default:
// Default to Error->Output to be compatible with V2.
fromType = PipelineResultTypes.Error;
break;
}
command.MergeMyResults(fromType, toType);
}
_powershell.AddCommand(command);
// Now the parameters and arguments.
foreach (var ast in commandAst.CommandElements.Skip(1))
{
var exprAst = ast as ExpressionAst;
if (exprAst != null)
{
VariableExpressionAst variableAst = null;
var usingExprAst = ast as UsingExpressionAst;
if (usingExprAst != null)
{
string usingAstKey = PsUtils.GetUsingExpressionKey(usingExprAst);
object usingValue = _usingValueMap[usingAstKey];
variableAst = usingExprAst.SubExpression as VariableExpressionAst;
if (variableAst != null && variableAst.Splatted)
{
// Support the splatting of a dictionary
var parameters = usingValue as System.Collections.IDictionary;
if (parameters != null)
{
_powershell.AddParameters(parameters);
}
else
{
// Support the splatting of an array
var arguments = usingValue as System.Collections.IEnumerable;
if (arguments != null)
{
foreach (object argument in arguments)
{
_powershell.AddArgument(argument);
}
}
else
{
// Splat the object directly.
_powershell.AddArgument(usingValue);
}
}
}
else
{
_powershell.AddArgument(usingValue);
}
continue;
}
variableAst = ast as VariableExpressionAst;
if (variableAst != null && variableAst.Splatted)
{
GetSplattedVariable(variableAst);
}
else
{
var constantExprAst = ast as ConstantExpressionAst;
object argument;
if (constantExprAst != null &&
(LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(constantExprAst.StaticType)) ||
constantExprAst.StaticType == typeof(System.Numerics.BigInteger)))
{
var commandArgumentText = constantExprAst.Extent.Text;
argument = constantExprAst.Value;
if (!commandArgumentText.Equals(constantExprAst.Value.ToString(), StringComparison.Ordinal))
{
// The wrapped number will actually return a PSObject which could end holding a reference to
// a typetable, making the object runspace specific. We should find a better way to avoid
// any possibility of sharing problems, though this is unlikely to cause problems.
argument = ParserOps.WrappedNumber(argument, commandArgumentText);
}
}
else
{
if (!isTrustedInput)
{
try
{
argument = GetSafeValueVisitor.GetSafeValue(exprAst, _context, GetSafeValueVisitor.SafeValueContext.GetPowerShell);
}
catch (System.Exception)
{
throw new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithDynamicExpression",
null,
AutomationExceptions.CantConvertWithDynamicExpression,
exprAst.Extent.Text);
}
}
else
{
argument = GetExpressionValue(exprAst, isTrustedInput);
}
}
_powershell.AddArgument(argument);
}
}
else
{
AddParameter((CommandParameterAst)ast, isTrustedInput);
}
}
}
public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(new VariableExpressionAst(variableExpressionAst.Extent, variableExpressionAst.VariablePath.UserPath,
variableExpressionAst.Splatted));
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst) => null;
/// <summary>
/// AvoidShouldContinueWithoutForceCheck that if ShouldContinue is used,
/// the function should have a boolean force parameter
/// </summary>
public IEnumerable <DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
{
if (ast == null)
{
throw new ArgumentNullException(Strings.NullAstErrorMessage);
}
// Finds all ParamAsts.
IEnumerable <Ast> funcAsts = ast.FindAll(testAst => testAst is FunctionDefinitionAst, true);
// Iterates all ParamAsts and check if there are any force.
foreach (FunctionDefinitionAst funcAst in funcAsts)
{
IEnumerable <Ast> paramAsts = funcAst.FindAll(testAst => testAst is ParameterAst, true);
bool hasForce = false;
foreach (ParameterAst paramAst in paramAsts)
{
if (String.Equals(paramAst.Name.VariablePath.ToString(), "force", StringComparison.OrdinalIgnoreCase) &&
(String.Equals(paramAst.StaticType.FullName, "System.Boolean", StringComparison.OrdinalIgnoreCase) ||
String.Equals(paramAst.StaticType.FullName, "System.Management.Automation.SwitchParameter", StringComparison.OrdinalIgnoreCase)))
{
hasForce = true;
break;
}
}
if (hasForce)
{
continue;
}
IEnumerable <Ast> imeAsts = funcAst.FindAll(testAst => testAst is InvokeMemberExpressionAst, true);
foreach (InvokeMemberExpressionAst imeAst in imeAsts)
{
VariableExpressionAst typeAst = imeAst.Expression as VariableExpressionAst;
if (typeAst == null)
{
continue;
}
if (String.Equals(typeAst.VariablePath.UserPath, "pscmdlet", StringComparison.OrdinalIgnoreCase) &&
(String.Equals(imeAst.Member.Extent.Text, "shouldcontinue", StringComparison.OrdinalIgnoreCase)))
{
if (String.IsNullOrWhiteSpace(fileName))
{
yield return(new DiagnosticRecord(
String.Format(CultureInfo.CurrentCulture, Strings.AvoidShouldContinueWithoutForceErrorScriptDefinition, funcAst.Name),
imeAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
else
{
yield return(new DiagnosticRecord(
String.Format(CultureInfo.CurrentCulture, Strings.AvoidShouldContinueWithoutForceError, funcAst.Name,
System.IO.Path.GetFileName(fileName)), imeAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
}
}
}
}
/// <summary>
/// TryGetVariableFromExpression: extracts the variable from an expression like an assignment
/// </summary>
/// <param name="expression"></param>
/// <param name="variableExpressionAst"></param>
private static bool TryGetVariableFromExpression(ExpressionAst expression, out VariableExpressionAst variableExpressionAst)
{
switch (expression)
{
case VariableExpressionAst variable:
variableExpressionAst = variable;
return(true);
case AttributedExpressionAst attributedAst:
return(TryGetVariableFromExpression(attributedAst.Child, out variableExpressionAst));
default:
variableExpressionAst = null;
return(false);
}
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast)
{
return(DoNextAction(ast));
}
internal static object GetVariableValue(VariablePath variablePath, ExecutionContext executionContext, VariableExpressionAst varAst)
{
if (!variablePath.IsVariable)
{
CmdletProviderContext contextOut;
SessionStateScope scopeOut;
SessionStateInternal ss = executionContext.EngineSessionState;
return(ss.GetVariableValueFromProvider(variablePath, out contextOut, out scopeOut, ss.CurrentScope.ScopeOrigin));
}
SessionStateInternal sessionState = executionContext.EngineSessionState;
CommandOrigin origin = sessionState.CurrentScope.ScopeOrigin;
SessionStateScope scope;
PSVariable var = sessionState.GetVariableItem(variablePath, out scope, origin);
if (var != null)
{
return(var.Value);
}
if (sessionState.ExecutionContext._debuggingMode > 0)
{
sessionState.ExecutionContext.Debugger.CheckVariableRead(variablePath.UnqualifiedPath);
}
if (ThrowStrictModeUndefinedVariable(executionContext, varAst))
{
throw InterpreterError.NewInterpreterException(variablePath.UserPath, typeof(RuntimeException),
varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, variablePath.UserPath);
}
return(null);
}
public override ExpressionAst VisitVariableExpression(VariableExpressionAst variableExpressionAst) => VisitExpression(base.VisitVariableExpression(variableExpressionAst));
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
Console.WriteLine("Visited an VariableExpressionAst.");
Console.WriteLine(" " + variableExpressionAst.ToString().Replace(Environment.NewLine, Environment.NewLine + " "));
return(AstVisitAction.Continue);
}
/// <summary>
/// Checks to see if this variable expression is the symbol we are looking for.
/// </summary>
/// <param name="variableExpressionAst">A VariableExpressionAst object in the script's AST</param>
/// <returns>A descion to stop searching if the right symbol was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(this.findSymbolsVisitor.VisitVariableExpression(variableExpressionAst));
}
public override object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
script_.Write("$" + variableExpressionAst.VariablePath);
return(variableExpressionAst);
}
/// <summary>
/// Checks if a variable is initialized and referenced in either its assignment or children scopes
/// </summary>
/// <param name="scriptBlockAst">Ast of type ScriptBlock</param>
/// <param name="fileName">Name of file containing the ast</param>
/// <returns>An enumerable containing diagnostic records</returns>
private IEnumerable <DiagnosticRecord> AnalyzeScriptBlockAst(ScriptBlockAst scriptBlockAst, string fileName)
{
IEnumerable <Ast> assignmentAsts = scriptBlockAst.FindAll(testAst => testAst is AssignmentStatementAst, false);
IEnumerable <Ast> varAsts = scriptBlockAst.FindAll(testAst => testAst is VariableExpressionAst, true);
IEnumerable <Ast> varsInAssignment;
Dictionary <string, AssignmentStatementAst> assignments = new Dictionary <string, AssignmentStatementAst>(StringComparer.OrdinalIgnoreCase);
string varKey;
bool inAssignment;
if (assignmentAsts == null)
{
yield break;
}
foreach (AssignmentStatementAst assignmentAst in assignmentAsts)
{
// Only checks for the case where lhs is a variable. Ignore things like $foo.property
VariableExpressionAst assignmentVarAst = assignmentAst.Left as VariableExpressionAst;
if (assignmentVarAst != null)
{
// Ignore if variable is global or environment variable or scope is function
if (!Helper.Instance.IsVariableGlobalOrEnvironment(assignmentVarAst, scriptBlockAst) &&
!assignmentVarAst.VariablePath.IsScript &&
!string.Equals(assignmentVarAst.VariablePath.DriveName, "function", StringComparison.OrdinalIgnoreCase))
{
string variableName = Helper.Instance.VariableNameWithoutScope(assignmentVarAst.VariablePath);
if (!assignments.ContainsKey(variableName))
{
assignments.Add(variableName, assignmentAst);
}
}
}
}
if (varAsts != null)
{
foreach (VariableExpressionAst varAst in varAsts)
{
varKey = Helper.Instance.VariableNameWithoutScope(varAst.VariablePath);
inAssignment = false;
if (assignments.ContainsKey(varKey))
{
varsInAssignment = assignments[varKey].Left.FindAll(testAst => testAst is VariableExpressionAst, true);
// Checks if this variableAst is part of the logged assignment
foreach (VariableExpressionAst varInAssignment in varsInAssignment)
{
inAssignment |= varInAssignment.Equals(varAst);
}
if (!inAssignment)
{
assignments.Remove(varKey);
}
// Check if variable belongs to PowerShell built-in variables
if (Helper.Instance.HasSpecialVars(varKey))
{
assignments.Remove(varKey);
}
}
}
}
foreach (string key in assignments.Keys)
{
yield return(new DiagnosticRecord(
string.Format(CultureInfo.CurrentCulture, Strings.UseDeclaredVarsMoreThanAssignmentsError, key),
assignments[key].Left.Extent,
GetName(),
DiagnosticSeverity.Warning,
fileName,
key));
}
}
internal static object GetAutomaticVariableValue(int tupleIndex, ExecutionContext executionContext, VariableExpressionAst varAst)
{
Diagnostics.Assert(tupleIndex < SpecialVariables.AutomaticVariableTypes.Length, "caller to verify a valid tuple index is used");
if (executionContext._debuggingMode > 0)
{
executionContext.Debugger.CheckVariableRead(SpecialVariables.AutomaticVariables[tupleIndex]);
}
object result = executionContext.EngineSessionState.GetAutomaticVariableValue((AutomaticVariable)tupleIndex);
if (result == AutomationNull.Value)
{
if (ThrowStrictModeUndefinedVariable(executionContext, varAst))
{
throw InterpreterError.NewInterpreterException(SpecialVariables.AutomaticVariables[tupleIndex], typeof(RuntimeException),
varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, SpecialVariables.AutomaticVariables[tupleIndex]);
}
result = null;
}
return(result);
}
private ExpressionAst CreateClosureAccess(VariableExpressionAst ast)
{
return(CreateClosureAccess(ast.Extent, ast.VariablePath.UserPath));
}
