// StatementBlockAst Extension Methods
// - CreateNode() => Return ElseIf, Else, SwitchCaseNode... because there is no specific AST for this kind
// - GetChildAst() => retourne only ASTs we are looking for ...
public static Node CreateNode(this StatementBlockAst _ast, int _depth, int _position, Node _parent, FlowChartCore.StatementType type)
{
switch (type)
{
case FlowChartCore.StatementType.Else: {
return(new ElseNode(_ast, _depth, _position, _parent));
}
case FlowChartCore.StatementType.ElseIf: {
return(new ElseIfNode(_ast, _depth, _position, _parent));
}
case FlowChartCore.StatementType.SwitchCase: {
return(new SwitchCaseNode(_ast, _depth, _position, _parent));
}
case FlowChartCore.StatementType.SwitchDefault: {
return(new SwitchDefaultNode(_ast, _depth, _position, _parent));
}
case FlowChartCore.StatementType.Finally: {
return(new FinallyNode(_ast, _depth, _position, _parent));
}
}
return(null);
}
public virtual StatementBlockAst VisitStatementBlock(StatementBlockAst statementBlockAst)
{
return(new StatementBlockAst(
statementBlockAst.Extent,
statementBlockAst.Statements?.RewriteAll(this, SyntaxKind.Statement),
statementBlockAst.Traps?.RewriteAll(this, SyntaxKind.Trap)));
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
ArrayList statementList = new ArrayList();
foreach (var statement in statementBlockAst.Statements)
{
if (statement != null)
{
var obj = statement.Accept(this);
var enumerator = LanguagePrimitives.GetEnumerator(obj);
if (enumerator != null)
{
while (enumerator.MoveNext())
{
statementList.Add(enumerator.Current);
}
}
else
{
statementList.Add(obj);
}
}
else
{
throw PSTraceSource.NewArgumentException("ast");
}
}
return(statementList.ToArray());
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
var newStatements = VisitStatements(statementBlockAst.Statements);
var newTraps = VisitElements(statementBlockAst.Traps);
return(new StatementBlockAst(statementBlockAst.Extent, newStatements, newTraps));
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
var statements = VisitAst(statementBlockAst.Statements);
var traps = VisitAst(statementBlockAst.Traps);
return(new StatementBlockAst(statementBlockAst.Extent, statements, traps));
}
public object VisitNamedBlock(NamedBlockAst namedBlockAst)
{
var newTraps = VisitElements(namedBlockAst.Traps);
var newStatements = VisitStatements(namedBlockAst.Statements);
var statementBlock = new StatementBlockAst(namedBlockAst.Extent, newStatements, newTraps);
return(new NamedBlockAst(namedBlockAst.Extent, namedBlockAst.BlockKind, statementBlock, namedBlockAst.Unnamed));
}
public System.Object VisitBlockStatement(System.Management.Automation.Language.BlockStatementAst blockStatementAst)
{
IScriptExtent mappedExtent = MapExtent(blockStatementAst.Extent);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(blockStatementAst.Body);
return(new BlockStatementAst(mappedExtent, blockStatementAst.Kind, mappedBody));
}
public System.Object VisitArrayExpression(System.Management.Automation.Language.ArrayExpressionAst arrayExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(arrayExpressionAst.Extent);
StatementBlockAst mappedStatementBlock = (StatementBlockAst)VisitStatementBlock(arrayExpressionAst.SubExpression);
return(new System.Management.Automation.Language.ArrayExpressionAst(mappedExtent, mappedStatementBlock));
}
public System.Object VisitWhileStatement(System.Management.Automation.Language.WhileStatementAst whileStatementAst)
{
IScriptExtent mappedExtent = MapExtent(whileStatementAst.Extent);
PipelineBaseAst mappedCondition = _VisitPipelineBase(whileStatementAst.Condition);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(whileStatementAst.Body);
return(new WhileStatementAst(mappedExtent, whileStatementAst.Label, mappedCondition, mappedBody));
}
public System.Object VisitTrap(System.Management.Automation.Language.TrapStatementAst trapStatementAst)
{
IScriptExtent mappedExtent = MapExtent(trapStatementAst.Extent);
TypeConstraintAst mappedTrapType = (TypeConstraintAst)VisitTypeConstraint(trapStatementAst.TrapType);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(trapStatementAst.Body);
return(new TrapStatementAst(mappedExtent, mappedTrapType, mappedBody));
}
public System.Object VisitForEachStatement(System.Management.Automation.Language.ForEachStatementAst forEachStatementAst)
{
IScriptExtent mappedExtent = MapExtent(forEachStatementAst.Extent);
VariableExpressionAst mappedVariable = (VariableExpressionAst)VisitVariableExpression(forEachStatementAst.Variable);
PipelineBaseAst mappedExpression = _VisitPipelineBase(forEachStatementAst.Condition);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(forEachStatementAst.Body);
return(new ForEachStatementAst(mappedExtent, forEachStatementAst.Label, forEachStatementAst.Flags, mappedVariable, mappedExpression, mappedBody));
}
public static StatementBlockAst Update(
this StatementBlockAst ast,
IEnumerable <StatementAst> statements = null,
IEnumerable <TrapStatementAst> traps = null)
{
return(new StatementBlockAst(
ast.Extent,
statements?.CloneAll() ?? ast.Statements.CloneAll(),
traps?.CloneAll() ?? ast.Traps.CloneAll()));
}
public IfStatementAst If(
PipelineBaseAst condition,
StatementBlockAst ifTrueBody,
StatementBlockAst ifFalseBody)
{
return(new IfStatementAst(
_currentExtent,
new[] { Tuple.Create(condition, ifTrueBody) },
ifFalseBody));
}
public System.Object VisitForStatement(System.Management.Automation.Language.ForStatementAst forStatementAst)
{
IScriptExtent mappedExtent = MapExtent(forStatementAst.Extent);
PipelineBaseAst mappedInitializer = _VisitPipelineBase(forStatementAst.Initializer);
PipelineBaseAst mappedCondition = _VisitPipelineBase(forStatementAst.Condition);
PipelineBaseAst mappedIterator = _VisitPipelineBase(forStatementAst.Iterator);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(forStatementAst.Body);
return(new ForStatementAst(mappedExtent, forStatementAst.Label, mappedInitializer, mappedCondition, mappedIterator, mappedBody));
}
public static TryStatementAst Update(
this TryStatementAst ast,
StatementBlockAst body = null,
IEnumerable <CatchClauseAst> catchClauses = null,
StatementBlockAst @finally = null)
{
return(new TryStatementAst(
ast.Extent,
body?.Clone() ?? ast.Body?.Clone(),
catchClauses?.CloneAll() ?? ast.CatchClauses?.CloneAll(),
@finally?.Clone() ?? ast.Finally?.Clone()));
}
public static WhileStatementAst Update(
this WhileStatementAst ast,
PipelineBaseAst condition = null,
StatementBlockAst body = null,
string label = null)
{
return(new WhileStatementAst(
ast.Extent,
label ?? ast.Label,
condition?.Clone() ?? ast.Condition?.Clone(),
body?.Clone() ?? ast.Body?.Clone()));
}
public static IfStatementAst As(
this Ast source,
AstType <IfStatementAst> targetType,
PipelineBaseAst condition,
StatementBlockAst ifTrueBody,
StatementBlockAst ifFalseBody)
{
return(new IfStatementAst(
source.Extent,
new[] { Tuple.Create(condition, ifTrueBody) },
ifFalseBody));
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
if (statementBlockAst.Traps != null)
{
return(false);
}
if (statementBlockAst.Statements.Count > 1)
{
return(false);
}
StatementAst ast = statementBlockAst.Statements.FirstOrDefault <StatementAst>();
return((ast == null) ? ((object)0) : ((object)((bool)ast.Accept(this))));
}
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 System.Object VisitDataStatement(System.Management.Automation.Language.DataStatementAst dataStatementAst)
{
IScriptExtent mappedExtent = MapExtent(dataStatementAst.Extent);
LinkedList <ExpressionAst> mappedCommandsAllowed = new LinkedList <ExpressionAst>();
foreach (ExpressionAst e in dataStatementAst.CommandsAllowed)
{
mappedCommandsAllowed.AddLast(_VisitExpression(e));
}
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(dataStatementAst.Body);
return(new DataStatementAst(mappedExtent, dataStatementAst.Variable, mappedCommandsAllowed, mappedBody));
}
public System.Object VisitCatchClause(System.Management.Automation.Language.CatchClauseAst catchClauseAst)
{
IScriptExtent mappedExtent = MapExtent(catchClauseAst.Extent);
LinkedList <TypeConstraintAst> mappedCatchTypes = new LinkedList <TypeConstraintAst>();
foreach (TypeConstraintAst tc in catchClauseAst.CatchTypes)
{
mappedCatchTypes.AddLast((TypeConstraintAst)VisitTypeConstraint(tc));
}
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(catchClauseAst.Body);
return(new CatchClauseAst(mappedExtent, mappedCatchTypes, mappedBody));
}
public System.Object VisitTryStatement(System.Management.Automation.Language.TryStatementAst tryStatementAst)
{
IScriptExtent mappedExtent = MapExtent(tryStatementAst.Extent);
StatementBlockAst mappedBody = (StatementBlockAst)VisitStatementBlock(tryStatementAst.Body);
LinkedList <CatchClauseAst> mappedCatchClauses = new LinkedList <CatchClauseAst>();
foreach (CatchClauseAst cc in tryStatementAst.CatchClauses)
{
mappedCatchClauses.AddLast((CatchClauseAst)VisitCatchClause(cc));
}
StatementBlockAst mappedFinally = tryStatementAst.Finally != null ? (StatementBlockAst)VisitStatementBlock(tryStatementAst.Finally) : null;
return(new TryStatementAst(mappedExtent, mappedBody, mappedCatchClauses, mappedFinally));
}
public static SwitchStatementAst Update(
this SwitchStatementAst ast,
string label = null,
PipelineBaseAst condition = null,
SwitchFlags?flags = null,
IEnumerable <Tuple <ExpressionAst, StatementBlockAst> > clauses = null,
StatementBlockAst @default = null)
{
return(new SwitchStatementAst(
ast.Extent,
label ?? ast.Label,
condition?.Clone() ?? ast.Condition?.Clone(),
flags ?? ast.Flags,
clauses?.CloneAll() ?? ast.Clauses?.CloneAll(),
@default?.Clone() ?? ast.Default?.Clone()));
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
if (statementBlockAst != null)
{
var statements = statementBlockAst.Statements;
if (statements != null)
{
var firstStatement = statements.FirstOrDefault();
if (firstStatement != null)
{
return(firstStatement.Visit(this));
}
}
}
return(null);
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
var statements = new CodeStatementCollection();
foreach (var code in statementBlockAst.Statements.Select(Visit))
{
if (code is CodeStatement)
{
statements.Add(code as CodeStatement);
}
if (code is CodeExpression)
{
statements.Add(code as CodeExpression);
}
}
return(statements);
}
public System.Object VisitIfStatement(System.Management.Automation.Language.IfStatementAst ifStmtAst)
{
IScriptExtent mappedExtent = MapExtent(ifStmtAst.Extent);
LinkedList <Tuple <PipelineBaseAst, StatementBlockAst> > mappedClauses = new LinkedList <Tuple <PipelineBaseAst, StatementBlockAst> >();
foreach (Tuple <PipelineBaseAst, StatementBlockAst> c in ifStmtAst.Clauses)
{
mappedClauses.AddLast(
new Tuple <PipelineBaseAst, StatementBlockAst>(
_VisitPipelineBase(c.Item1),
(StatementBlockAst)VisitStatementBlock(c.Item2)
)
);
}
StatementBlockAst mappedElseClause = ifStmtAst.ElseClause != null ? (StatementBlockAst)VisitStatementBlock(ifStmtAst.ElseClause) : null;
return(new IfStatementAst(mappedExtent, mappedClauses, mappedElseClause));
}
public override AstVisitAction VisitStatementBlock(StatementBlockAst statementBlockAst)
{
if (statementBlockAst.Parent is TryStatementAst &
// Ugly hack. Finally block is undistinguisable from the Try block, except for textual position.
statementBlockAst.Extent.StartColumnNumber > statementBlockAst.Parent.Extent.StartColumnNumber + 5)
{
explanations.Add(new Explanation()
{
CommandName = "Finally block, belongs to Try statement",
HelpResult = HelpTableQuery("about_try_catch_finally"),
Description = "The Finally block is always run after the Try block, regardless of Exceptions. Intended for cleanup actions that should always be run.",
}.AddDefaults(statementBlockAst, explanations));
explanations.Last().OriginalExtent = "Finally " + explanations.Last().OriginalExtent;
return(AstVisitAction.Continue);
}
//AstExplainer(statementBlockAst);
return(base.VisitStatementBlock(statementBlockAst));
}
public System.Object VisitSwitchStatement(System.Management.Automation.Language.SwitchStatementAst switchStatementAst)
{
IScriptExtent mappedExtent = MapExtent(switchStatementAst.Extent);
PipelineBaseAst mappedCondition = _VisitPipelineBase(switchStatementAst.Condition);
LinkedList <Tuple <ExpressionAst, StatementBlockAst> > mappedClauses = new LinkedList <Tuple <ExpressionAst, StatementBlockAst> >();
foreach (Tuple <ExpressionAst, StatementBlockAst> c in switchStatementAst.Clauses)
{
mappedClauses.AddLast(
new Tuple <ExpressionAst, StatementBlockAst>(
_VisitExpression(c.Item1),
(StatementBlockAst)VisitStatementBlock(c.Item2)
)
);
}
StatementBlockAst mappedDefault = switchStatementAst.Default == null ? null : (StatementBlockAst)VisitStatementBlock(switchStatementAst.Default);
return(new SwitchStatementAst(mappedExtent, switchStatementAst.Label, mappedCondition, switchStatementAst.Flags, mappedClauses, mappedDefault));
}
public override AstVisitAction VisitStatementBlock(StatementBlockAst statementBlockAst)
{
var statements = new List <Node>();
foreach (var statement in statementBlockAst.Statements)
{
statements.Add(VisitSyntaxNode(statement));
}
if (statements.Count() == 1)
{
_currentNode = statements.FirstOrDefault();
}
else
{
_currentNode = new Block(statements);
}
return(AstVisitAction.SkipChildren);
}
public object VisitStatementBlock(StatementBlockAst statementBlockAst)
{
bool isSafe = true;
foreach (var statement in statementBlockAst.Statements)
{
_visitCount++;
if (statement == null)
{
isSafe = false;
break;
}
if (!(bool)statement.Accept(this))
{
isSafe = false;
break;
}
}
return(isSafe);
}
