public void SetUp()
{
extent = Substitute.For<IScriptExtent>();
argument = new VariableExpressionAst(extent, "other", false);
visitor = new FindTypeDefinitionVisitor();
}
public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue)
: base(extent)
{
this.Name = name;
this.Attributes = attributes.ToReadOnlyCollection();
this.DefaultValue = defaultValue;
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast)
{
if (IsTypeDefinitionAst)
VarName = ast.VariablePath.UserPath;
return AstVisitAction.Continue;
}
public void LastAssignmentStatementAst_should_be_null_when_not_equals_operation()
{
var leftExpressionAst = new VariableExpressionAst(extent, varName, false);
var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.MinusEquals);
visitor.VisitAssignmentStatement(assignmentStatementAst);
visitor.LastAssignmentStatementAst.Should().BeNull();
}
public void LastAssignmentStatementAst_should_be_ast()
{
var leftExpressionAst = new VariableExpressionAst(extent, varName , false);
var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.Equals);
visitor.VisitAssignmentStatement(assignmentStatementAst);
visitor.LastAssignmentStatementAst.Should().BeSameAs(assignmentStatementAst);
}
public void LastAssignmentStatementAst_should_be_null_after_visit_command()
{
var leftExpressionAst = new VariableExpressionAst(extent, varName, false);
var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.Equals);
visitor.VisitCommand(commandAst);
visitor.VisitAssignmentStatement(assignmentStatementAst);
visitor.LastAssignmentStatementAst.Should().BeNull();
}
private void AddVariable(int startIndex, int endIndex)
{
if (endIndex <= startIndex + 1)
return;
string variableName = GetText(startIndex + 1, endIndex);
IScriptExtent variableExtent = GetScriptExtent(startIndex, endIndex);
var variableAst = new VariableExpressionAst(variableExtent, variableName, false);
_nestedExpressions.Add(variableAst);
}
public ForEachStatementAst(IScriptExtent extent, string label, ForEachFlags flags, VariableExpressionAst variable, PipelineBaseAst expression, StatementBlockAst body) : base(extent, label, expression, body)
{
if ((expression == null) || (variable == null))
{
throw PSTraceSource.NewArgumentNullException((expression == null) ? "expression" : "variablePath");
}
this.Flags = flags;
this.Variable = variable;
base.SetParent(variable);
}
/// <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)
{
if (!IsAssignedAtScriptScope(variableExpressionAst))
{
return AstVisitAction.Continue;
}
this.SymbolReferences.Add(
new SymbolReference(
SymbolType.Variable,
variableExpressionAst.Extent));
return AstVisitAction.Continue;
}
/// <summary>
/// Decides if the current variable expression is the right defition for
/// the symbol being searched for. The defintion of the symbol will be a of type
/// SymbolType.Variable and have the same name as the symbol
/// </summary>
/// <param name="variableExpressionAst">A FunctionDefinitionAst in the script's AST</param>
/// <returns>A descion to stop searching if the right VariableExpressionAst was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
if(symbolRef.SymbolType.Equals(SymbolType.Variable) &&
variableExpressionAst.Extent.Text.Equals(symbolRef.SymbolName, StringComparison.InvariantCultureIgnoreCase))
{
this.FoundDeclartion =
new SymbolReference(
SymbolType.Variable,
variableExpressionAst.Extent);
return AstVisitAction.StopVisit;
}
return AstVisitAction.Continue;
}
private bool IsAssignedAtScriptScope(VariableExpressionAst variableExpressionAst)
{
Ast parent = variableExpressionAst.Parent;
if (!(parent is AssignmentStatementAst))
{
return false;
}
parent = parent.Parent;
if (parent == null || parent.Parent == null || parent.Parent.Parent == null)
{
return true;
}
return false;
}
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;
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
bool flag = false;
if (variableExpressionAst.VariablePath.IsAnyLocal())
{
string unqualifiedPath = variableExpressionAst.VariablePath.UnqualifiedPath;
if (this._validVariables.Contains(unqualifiedPath) || unqualifiedPath.Equals("args", StringComparison.OrdinalIgnoreCase))
{
flag = true;
this.UsesParameter = true;
}
else
{
flag = !variableExpressionAst.Splatted && variableExpressionAst.IsConstantVariable();
}
}
if (!flag)
{
ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithUndeclaredVariables", null, AutomationExceptions.CantConvertWithUndeclaredVariables, new object[] { variableExpressionAst.VariablePath }), variableExpressionAst);
}
return AstVisitAction.Continue;
}
public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue) : base(extent)
{
if (name == null)
{
throw PSTraceSource.NewArgumentNullException("name");
}
if ((attributes != null) && attributes.Any<AttributeBaseAst>())
{
this.Attributes = new ReadOnlyCollection<AttributeBaseAst>(attributes.ToArray<AttributeBaseAst>());
base.SetParents(attributes);
}
else
{
this.Attributes = EmptyAttributeList;
}
this.Name = name;
base.SetParent(name);
if (defaultValue != null)
{
this.DefaultValue = defaultValue;
base.SetParent(defaultValue);
}
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(variableExpressionAst.IsConstantVariable());
}
private void GetSplattedVariable(VariableExpressionAst variableAst)
{
if (_context == null)
{
throw new PSInvalidOperationException(AutomationExceptions.CantConvertScriptBlockWithNoContext);
}
// Process the contents of a splatted variable into the arguments for this
// command. If the variable contains a hashtable, distribute the key/value pairs
// If it's an enumerable, then distribute the values as $args and finally
// if it's a scalar, then the effect is equivalent to $var
object splattedValue = _context.GetVariableValue(variableAst.VariablePath);
foreach (var splattedParameter in PipelineOps.Splat(splattedValue, variableAst.Extent))
{
CommandParameter publicParameter = CommandParameter.FromCommandParameterInternal(splattedParameter);
_powershell.AddParameter(publicParameter.Name, publicParameter.Value);
}
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
bool usesParameterReference = this.UsesParameter;
bool ok = variableExpressionAst.IsSafeVariableReference(_validVariables, ref usesParameterReference);
if (usesParameterReference != this.UsesParameter)
{
this.UsesParameter = usesParameterReference;
}
if (!ok)
{
ThrowError(new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithUndeclaredVariables",
null,
AutomationExceptions.CantConvertWithUndeclaredVariables,
variableExpressionAst.VariablePath),
variableExpressionAst);
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
_pipelineCommandRuntime.WriteObject(new SettableVariableExpression(variableExpressionAst, this).GetValue());
return AstVisitAction.SkipChildren;
}
/// <summary/>
public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return _decorated.VisitVariableExpression(variableExpressionAst);
}
/// <summary/> public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) => DefaultVisit(variableExpressionAst);
public ForEachStatementAst(IScriptExtent extent, string label, ForEachFlags flags, VariableExpressionAst variable, PipelineBaseAst expression, StatementBlockAst body)
: base(extent, label, expression, body)
{
this.Flags = flags;
this.Variable = variable;
}
/// <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 virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
var variable = GetVariable(variableExpressionAst);
this._pipelineCommandRuntime.WriteObject(variable.Value, true);
return AstVisitAction.SkipChildren;
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast)
{
return(Check(ast));
}
/// <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)
{
if (this.IsPositionInExtent(variableExpressionAst.Extent))
{
this.FoundSymbolReference =
new SymbolReference(
SymbolType.Variable,
variableExpressionAst.Extent);
return AstVisitAction.StopVisit;
}
return AstVisitAction.Continue;
}
/// <summary>
/// Visit variable expression
/// </summary>
/// <param name="variableExpressionAst"></param>
/// <returns></returns>
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return null;
}
/// <summary/>
public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(null);
}
internal string ToStringForSerialization(Tuple <List <VariableExpressionAst>, string> usingVariablesTuple, int initialStartOffset, int initialEndOffset)
{
List <VariableExpressionAst> collection = usingVariablesTuple.Item1;
string str = usingVariablesTuple.Item2;
List <Ast> list2 = new List <Ast>(collection);
if (this.ParamBlock != null)
{
list2.Add(this.ParamBlock);
}
int startOffset = base.Extent.StartOffset;
int startIndex = initialStartOffset - startOffset;
int num3 = initialEndOffset - startOffset;
string str2 = this.ToString();
StringBuilder builder = new StringBuilder();
foreach (Ast ast in from ast in list2
orderby ast.Extent.StartOffset
select ast)
{
int num4 = ast.Extent.StartOffset - startOffset;
int num5 = ast.Extent.EndOffset - startOffset;
if (num4 >= startIndex)
{
if (num4 >= num3)
{
break;
}
VariableExpressionAst ast2 = ast as VariableExpressionAst;
if (ast2 != null)
{
string userPath = ast2.VariablePath.UserPath;
string str4 = ast2.Splatted ? "@" : "$";
string str5 = str4 + "__using_" + userPath;
builder.Append(str2.Substring(startIndex, num4 - startIndex));
builder.Append(str5);
startIndex = num5;
}
else
{
int num6;
ParamBlockAst ast3 = ast as ParamBlockAst;
if (ast3.Parameters.Count == 0)
{
num6 = num5 - 1;
}
else
{
ParameterAst ast4 = ast3.Parameters[0];
num6 = (ast4.Attributes.Count == 0) ? (ast4.Name.Extent.StartOffset - startOffset) : (ast4.Attributes[0].Extent.StartOffset - startOffset);
str = str + ",\n";
}
builder.Append(str2.Substring(startIndex, num6 - startIndex));
builder.Append(str);
startIndex = num6;
}
}
}
builder.Append(str2.Substring(startIndex, num3 - startIndex));
string str6 = builder.ToString();
if (((base.Parent is ScriptBlockExpressionAst) && (initialStartOffset == base.Extent.StartOffset)) && (initialEndOffset == base.Extent.EndOffset))
{
str6 = str6.Substring(1, str6.Length - 2);
}
return(str6);
}
public System.Object VisitVariableExpression(System.Management.Automation.Language.VariableExpressionAst variableExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(variableExpressionAst.Extent);
return(new VariableExpressionAst(mappedExtent, variableExpressionAst.VariablePath, variableExpressionAst.Splatted));
}
public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return(AstVisitAction.Continue);
}
private PSVariable GetVariable(VariableExpressionAst variableExpressionAst)
{
var variable = this._context.SessionState.PSVariable.Get(variableExpressionAst.VariablePath.UserPath);
return variable;
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
VariablePath variablePath = variableExpressionAst.VariablePath;
if (variablePath.IsAnyLocal())
{
VariableAnalysisDetails details = this._variables[GetUnaliasedVariableName(variablePath)];
if (details.LocalTupleIndex != -1)
{
variableExpressionAst.TupleIndex = details.PreferenceVariable ? -2 : details.LocalTupleIndex;
variableExpressionAst.Automatic = details.Automatic;
}
else
{
this._currentBlock.AddAst(variableExpressionAst);
}
details.AssociatedAsts.Add(variableExpressionAst);
}
else
{
variableExpressionAst.TupleIndex = -2;
}
return null;
}
internal SettableVariableExpression(VariableExpressionAst expressionAst, ExecutionVisitor currentExecution)
: base(currentExecution)
{
_expressionAst = expressionAst;
}
/// <summary>
/// Constructor that takes in a VariableExpressionAst
/// </summary>
/// <param name="varExpression"></param>
public VariableTarget(VariableExpressionAst varExpression)
{
if (varExpression != null)
{
Name = AssignmentTarget.GetUnaliasedVariableName(varExpression.VariablePath);
VarAst = varExpression;
RealName = Name;
}
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
return variableExpressionAst.IsConstantVariable();
}
private void SetVariableName()
{
ExpressionAst lhs = (_targetAst is ConvertExpressionAst) ? (_targetAst as ConvertExpressionAst).Child : _targetAst;
_leftHandSideVariable = lhs as VariableExpressionAst;
if (_leftHandSideVariable == null)
{
return;
}
Name = GetUnaliasedVariableName(_leftHandSideVariable.VariablePath);
RealName = Name;
}
/// <summary>
/// Visit VariableExpression
/// </summary>
/// <param name="variableExpressionAst"></param>
/// <returns></returns>
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
if (variableExpressionAst == null)
{
return AstVisitAction.Continue;
}
NoteVariable(AssignmentTarget.GetUnaliasedVariableName(variableExpressionAst.VariablePath), null);
return AstVisitAction.Continue;
}
public ForEachStatementAst(IScriptExtent extent, string label, ForEachFlags flags, VariableExpressionAst variable, PipelineBaseAst expression, StatementBlockAst body) : base(extent, label, expression, body)
{
if ((expression == null) || (variable == null))
{
throw PSTraceSource.NewArgumentNullException((expression == null) ? "expression" : "variablePath");
}
this.Flags = flags;
this.Variable = variable;
base.SetParent(variable);
}
