public void AssignmentTest()
{
AssignmentStatementAst assignmentStatementAst = ParseInput("$x = 'y'").
EndBlock.
Statements[0];
Assert.AreEqual(TokenKind.Equals, assignmentStatementAst.Operator);
}
public override StatementAst VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
// Don't rewrite the LHS of an assignment.
var newAssignment = assignmentStatementAst.Update(
right: assignmentStatementAst.Right.Rewrite(this));
return(Assignment(Variables.Null, CreateLoggingExpression(newAssignment)));
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
if (string.Equals("$env:PATH", assignmentStatementAst.Left.ToString(), StringComparison.OrdinalIgnoreCase) && Regex.IsMatch(assignmentStatementAst.Right.ToString(), @"\$psScriptRoot", RegexOptions.IgnoreCase))
{
ModuleIntrinsics.Tracer.WriteLine("Module adds itself to the path.", new object[0]);
this.AddsSelfToPath = true;
}
return(AstVisitAction.Continue);
}
public virtual StatementAst VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
return(new AssignmentStatementAst(
assignmentStatementAst.Extent,
assignmentStatementAst.Left.Rewrite(this, SyntaxKind.Expression),
assignmentStatementAst.Operator,
assignmentStatementAst.Right.Rewrite(this, SyntaxKind.Statement),
assignmentStatementAst.ErrorPosition));
}
// Capture modules that add themselves to the path (so they generally package their functionality
// as loose PS1 files)
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
// $env:PATH += "";$psScriptRoot""
if (String.Equals("$env:PATH", assignmentStatementAst.Left.ToString(), StringComparison.OrdinalIgnoreCase) &&
Regex.IsMatch(assignmentStatementAst.Right.ToString(), "\\$psScriptRoot", RegexOptions.IgnoreCase))
{
ModuleIntrinsics.Tracer.WriteLine("Module adds itself to the path.");
AddsSelfToPath = true;
}
return AstVisitAction.SkipChildren;
}
public static AssignmentStatementAst Update(
this AssignmentStatementAst ast,
ExpressionAst left = null,
TokenKind? @operator = null,
StatementAst right = null)
{
return(new AssignmentStatementAst(
ast.Extent,
left?.Clone() ?? ast.Left.Clone(),
@operator ?? ast.Operator,
right?.Clone() ?? ast.Right.Clone(),
ast.ErrorPosition));
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
if (!TargetsNonPS7())
{
return(AstVisitAction.Continue);
}
if (assignmentStatementAst.Operator == TokenKind.QuestionQuestionEquals)
{
AddDiagnostic(assignmentStatementAst, "null-conditional assignment", "$x ??= $y", "3,4,5,6");
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
var(operatorExplanation, tokenHelpQuery) = Helpers.TokenExplainer(assignmentStatementAst.Operator);
explanations.Add(
new Explanation()
{
CommandName = $"Assignment operator '{assignmentStatementAst.Operator.Text()}'",
HelpResult = HelpTableQuery(tokenHelpQuery),
Description = $"{operatorExplanation} Assigns a value to '{assignmentStatementAst.Left.Extent.Text}'.",
TextToHighlight = assignmentStatementAst.Operator.Text()
}.AddDefaults(assignmentStatementAst, explanations));
return(AstVisitAction.Continue);
}
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
_paramBlockExtent = assignmentStatementAst.Left.Extent;
DelegateParameterVisitor.AddVariables(
assignmentStatementAst.Left,
_variables);
var pipeline = assignmentStatementAst.Right as PipelineAst;
if (pipeline == null)
{
return(null);
}
var commandAst = pipeline.PipelineElements[0] as CommandAst;
if (commandAst == null ||
commandAst.GetCommandName() != Strings.DelegateSyntaxCommandName ||
commandAst.CommandElements.Count != 2)
{
return(null);
}
if (commandAst.CommandElements[1] is ScriptBlockExpressionAst sbAst)
{
return(sbAst.ScriptBlock.EndBlock);
}
var expression = commandAst.CommandElements[1] as ExpressionAst;
var statements =
new StatementAst[]
{
new CommandExpressionAst(
expression.Extent,
(ExpressionAst)expression.Copy(),
s_emptyRedirections)
};
var statementBlockAst = new StatementBlockAst(
commandAst.CommandElements[1].Extent,
statements,
s_emptyTraps);
return(new NamedBlockAst(
commandAst.CommandElements[1].Extent,
TokenKind.End,
statementBlockAst,
unnamed: true));
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
var variableExpressionAst = assignmentStatementAst.Left as VariableExpressionAst;
if (variableExpressionAst == null)
{
throw new NotImplementedException(assignmentStatementAst.ToString());
}
var variable = this._context.SessionState.SessionStateGlobal.SetVariable(variableExpressionAst.VariablePath.UserPath, EvaluateAst(assignmentStatementAst.Right));
this._pipelineCommandRuntime.WriteObject(variable);
return(AstVisitAction.SkipChildren);
}
/// <summary>
/// Check if the left hand side of an assignmentStatementAst is a VariableExpressionAst
/// with the same name as that of symbolRef.
/// </summary>
/// <param name="assignmentStatementAst">An AssignmentStatementAst</param>
/// <returns>A decision to stop searching if the right VariableExpressionAst was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
var variableExprAst = assignmentStatementAst.Left as VariableExpressionAst;
if (variableExprAst == null ||
variableName == null ||
!variableExprAst.VariablePath.UserPath.Equals(
variableName,
StringComparison.OrdinalIgnoreCase))
{
return(AstVisitAction.Continue);
}
// TODO also find instances of set-variable
FoundDeclaration = new SymbolReference(SymbolType.Variable, variableExprAst.Extent);
return(AstVisitAction.StopVisit);
}
/// <summary>
/// Check if the left hand side of an assignmentStatementAst is a VariableExpressionAst
/// with the same name as that of symbolRef.
/// </summary>
/// <param name="assignmentStatementAst">An AssignmentStatementAst</param>
/// <returns>A decision to stop searching if the right VariableExpressionAst was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
if (variableName == null)
{
return(AstVisitAction.Continue);
}
// We want to check VariableExpressionAsts from within this AssignmentStatementAst so we visit it.
FindDeclarationVariableExpressionVisitor visitor = new FindDeclarationVariableExpressionVisitor(symbolRef);
assignmentStatementAst.Left.Visit(visitor);
if (visitor.FoundDeclaration != null)
{
FoundDeclaration = visitor.FoundDeclaration;
return(AstVisitAction.StopVisit);
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
var rightValue = EvaluateAst(assignmentStatementAst.Right);
ExpressionAst expressionAst = assignmentStatementAst.Left;
var variableExpressionAst = expressionAst as VariableExpressionAst;
if (variableExpressionAst == null)
{
throw new NotImplementedException(expressionAst.ToString());
}
this._context.SessionState.SessionStateGlobal.SetVariable(variableExpressionAst.VariablePath.UserPath, rightValue);
if (this._writeSideEffectsToPipeline)
{
this._pipelineCommandRuntime.WriteObject(rightValue);
}
return(AstVisitAction.SkipChildren);
}
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
if (_currentClass == null && assignmentStatementAst.Left is VariableExpressionAst)
{
var variableName = (assignmentStatementAst.Left as VariableExpressionAst).VariablePath.ToString();
if (variableName.Equals("MainForm", StringComparison.OrdinalIgnoreCase))
{
_currentClass = new CodeTypeDeclaration(variableName);
var codeNamespace = unit.Namespaces.Cast <CodeNamespace>().FirstOrDefault();
if (codeNamespace == null)
{
codeNamespace = new CodeNamespace("ns");
unit.Namespaces.Add(codeNamespace);
}
_currentConstructor = new CodeConstructor();
_currentConstructor.Attributes = MemberAttributes.Public;
_currentClass.Members.Add(_currentConstructor);
_currentClass.BaseTypes.Add("System.Windows.Forms.Form");
codeNamespace.Types.Add(_currentClass);
return(new CodeExpression());
}
}
var left = Visit(assignmentStatementAst.Left) as CodeExpression;
if (_currentClass != null && _currentMethod == null && left is CodeVariableReferenceExpression)
{
var variableName = (left as CodeVariableReferenceExpression).VariableName;
_currentClass.Members.Add(new CodeMemberField("System.Object", variableName));
return(new CodeExpression());
}
var rightEx = Visit(assignmentStatementAst.Right) as CodeExpression;
return(new CodeAssignStatement(left, rightEx));
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
if (assignmentStatementAst.Left is ConvertExpressionAst)
{
var varExpression = assignmentStatementAst.Left as ConvertExpressionAst;
if (varExpression.Attribute != null && varExpression.Child is VariableExpressionAst)
{
var typeName = varExpression.Attribute.TypeName.Name;
var name = (varExpression.Child as VariableExpressionAst).VariablePath.ToString();
var initializer = VisitSyntaxNode(assignmentStatementAst.Right);
_currentNode = new VariableDeclaration(typeName, new VariableDeclarator(name, initializer));
return(AstVisitAction.SkipChildren);
}
}
var left = VisitSyntaxNode(assignmentStatementAst.Left);
var right = VisitSyntaxNode(assignmentStatementAst.Right);
_currentNode = new Assignment(left, right);
return(AstVisitAction.SkipChildren);
}
/// <summary/> public virtual AstVisitAction VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst) => DefaultVisit(assignmentStatementAst);
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
object ICustomAstVisitor.VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst) => ProcessRewriter(VisitAssignmentStatement, assignmentStatementAst);
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
throw new UnexpectedElementException();
}
public override StatementAst VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst) => VisitStatement(base.VisitAssignmentStatement(assignmentStatementAst));
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst ast)
{
return(DoNextAction(ast));
}
object ICustomAstVisitor.VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst) => VisitAssignmentStatement(assignmentStatementAst);
public virtual object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
VisitElement(assignmentStatementAst.Left);
VisitElement(assignmentStatementAst.Right);
return(assignmentStatementAst);
}
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
Console.WriteLine("Visited an AssignmentStatementAst.");
return(assignmentStatementAst);
}
public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst ast)
{
return(AstVisitAction.Continue);
}
