public override AstVisitAction VisitConstantExpression(ConstantExpressionAst ast) { return CheckParent(ast); }
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
this._pipelineCommandRuntime.outputResults.Write(constantExpressionAst.Value);
return AstVisitAction.SkipChildren;
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return true;
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
CheckIsConstant(constantExpressionAst, "Caller to verify ast is constant");
return(constantExpressionAst.Value);
}
public void Setup()
{
this._constantExpressionAst = ParseInput("1")
.EndBlock
.Statements[0]
.PipelineElements[0]
.Expression;
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst ast)
{
return(this.Check(ast));
}
public virtual AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return(AstVisitAction.Continue);
}
/// <summary/> public virtual AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst) => DefaultVisit(constantExpressionAst);
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
_visitCount++;
return true;
}
private void AttributeArgumentsRule(ICollection<ExpressionAst> positionalArguments, ICollection<NamedAttributeArgumentAst> namedArguments, ref IScriptExtent lastItemExtent)
{
ExpressionAst constantExpressionAst;
bool flag = this._disableCommaOperator;
Token token = null;
HashSet<string> strs = new HashSet<string>();
try
{
this._disableCommaOperator = true;
while (true)
{
this.SkipNewlines();
StringConstantExpressionAst stringConstantExpressionAst = this.SimpleNameRule();
bool flag1 = false;
if (stringConstantExpressionAst == null)
{
constantExpressionAst = this.ExpressionRule();
}
else
{
Token token1 = this.PeekToken();
if (token1.Kind != TokenKind.Equals)
{
constantExpressionAst = new ConstantExpressionAst(stringConstantExpressionAst.Extent, (object)(true));
flag1 = true;
this.NoteV3FeatureUsed();
}
else
{
token1 = this.NextToken();
this.SkipNewlines();
constantExpressionAst = this.ExpressionRule();
if (constantExpressionAst == null)
{
IScriptExtent scriptExtent = Parser.After(token1);
this.ReportIncompleteInput(scriptExtent, ParserStrings.MissingExpressionInNamedArgument, new object[0]);
constantExpressionAst = new ErrorExpressionAst(scriptExtent, null);
TokenKind[] tokenKindArray = new TokenKind[4];
tokenKindArray[0] = TokenKind.Comma;
tokenKindArray[1] = TokenKind.RParen;
tokenKindArray[2] = TokenKind.RBracket;
tokenKindArray[3] = TokenKind.NewLine;
this.SyncOnError(tokenKindArray);
}
lastItemExtent = constantExpressionAst.Extent;
}
}
if (stringConstantExpressionAst == null)
{
if (constantExpressionAst == null)
{
if (token != null)
{
IScriptExtent scriptExtent1 = Parser.After(token);
object[] objArray = new object[1];
objArray[0] = token.Kind.Text();
this.ReportIncompleteInput(scriptExtent1, ParserStrings.MissingExpressionAfterToken, objArray);
positionalArguments.Add(new ErrorExpressionAst(scriptExtent1, null));
lastItemExtent = scriptExtent1;
}
}
else
{
positionalArguments.Add(constantExpressionAst);
lastItemExtent = constantExpressionAst.Extent;
}
}
else
{
if (!strs.Contains(stringConstantExpressionAst.Value))
{
namedArguments.Add(new NamedAttributeArgumentAst(Parser.ExtentOf(stringConstantExpressionAst, constantExpressionAst), stringConstantExpressionAst.Value, constantExpressionAst, flag1));
}
else
{
object[] value = new object[1];
value[0] = stringConstantExpressionAst.Value;
this.ReportError(stringConstantExpressionAst.Extent, ParserStrings.DuplicateNamedArgument, value);
}
}
this.SkipNewlines();
token = this.PeekToken();
if (token.Kind != TokenKind.Comma)
{
break;
}
lastItemExtent = token.Extent;
this.SkipToken();
}
}
finally
{
this._disableCommaOperator = flag;
}
}
private ExpressionAst PrimaryExpressionRule(bool withMemberAccess)
{
ExpressionAst constantExpressionAst;
Token token = this.NextToken();
TokenKind kind = token.Kind;
if (kind == TokenKind.Variable || kind == TokenKind.SplattedVariable)
{
constantExpressionAst = this.CheckUsingVariable((VariableToken)token, withMemberAccess);
if (withMemberAccess)
{
return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst);
}
else
{
return constantExpressionAst;
}
this.UngetToken(token);
return null;
}
else if (kind == TokenKind.Parameter)
{
this.UngetToken(token);
return null;
}
else if (kind == TokenKind.Number)
{
constantExpressionAst = new ConstantExpressionAst((NumberToken)token);
if (withMemberAccess)
{
return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst);
}
else
{
return constantExpressionAst;
}
this.UngetToken(token);
return null;
}
if (kind == TokenKind.StringLiteral || kind == TokenKind.HereStringLiteral)
{
constantExpressionAst = new StringConstantExpressionAst((StringToken)token);
}
else if (kind == TokenKind.StringExpandable || kind == TokenKind.HereStringExpandable)
{
constantExpressionAst = this.ExpandableStringRule((StringExpandableToken)token);
}
else if (kind == TokenKind.LParen)
{
constantExpressionAst = this.ParenthesizedExpressionRule(token);
}
else if (kind == TokenKind.RParen || kind == TokenKind.RCurly || kind == TokenKind.LBracket || kind == TokenKind.RBracket)
{
this.UngetToken(token);
return null;
}
else if (kind == TokenKind.LCurly)
{
constantExpressionAst = this.ScriptBlockExpressionRule(token);
}
else if (kind == TokenKind.AtParen || kind == TokenKind.DollarParen)
{
constantExpressionAst = this.SubExpressionRule(token);
}
else if (kind == TokenKind.AtCurly)
{
constantExpressionAst = this.HashExpressionRule(token);
}
else
{
this.UngetToken(token);
return null;
}
if (withMemberAccess)
{
return this.CheckPostPrimaryExpressionOperators(this.NextMemberAccessToken(true), constantExpressionAst);
}
else
{
return constantExpressionAst;
}
this.UngetToken(token);
return null;
}
private ExpressionAst PrimaryExpressionRule(bool withMemberAccess)
{
//G primary-expression:
//G value
//G member-access
//G element-access
//G invocation-expression
//G post-increment-expression
//G post-decrement-expression
//G value:
//G parenthesized-expression
//G sub-expression
//G array-expression
//G script-block-expression
//G hash-literal-expression
//G literal
//G type-literal
//G variable
ExpressionAst expr;
Token token = NextToken();
switch (token.Kind)
{
case TokenKind.SplattedVariable:
case TokenKind.Variable:
expr = CheckUsingVariable((VariableToken)token, withMemberAccess: withMemberAccess);
break;
case TokenKind.Number:
expr = new ConstantExpressionAst((NumberToken)token);
break;
case TokenKind.HereStringExpandable:
case TokenKind.StringExpandable:
expr = ExpandableStringRule((StringExpandableToken)token);
break;
case TokenKind.HereStringLiteral:
case TokenKind.StringLiteral:
expr = new StringConstantExpressionAst((StringToken)token);
break;
case TokenKind.LParen:
expr = ParenthesizedExpressionRule(token);
break;
case TokenKind.AtParen:
case TokenKind.DollarParen:
expr = SubExpressionRule(token);
break;
case TokenKind.AtCurly:
expr = HashExpressionRule(token, false /* parsingSchemaElement */ );
break;
case TokenKind.LCurly:
expr = ScriptBlockExpressionRule(token);
break;
default:
UngetToken(token);
return null;
}
if (!withMemberAccess)
{
return expr;
}
return CheckPostPrimaryExpressionOperators(NextMemberAccessToken(true), expr);
}
private void AttributeArgumentsRule(ICollection<ExpressionAst> positionalArguments,
ICollection<NamedAttributeArgumentAst> namedArguments,
ref IScriptExtent lastItemExtent)
{
//G attribute-arguments:
//G attribute-argument
//G attribute-argument new-lines:opt ',' attribute-arguments
//G attribute-argument:
//G new-lines:opt expression
//G new-lines:opt property-name '=' new-lines:opt expression
bool oldDisableCommaOperator = _disableCommaOperator;
Token commaToken = null;
HashSet<string> keysSeen = new HashSet<string>();
try
{
_disableCommaOperator = true;
while (true)
{
SkipNewlines();
StringConstantExpressionAst name = SimpleNameRule();
ExpressionAst expr;
bool expressionOmitted = false;
if (name != null)
{
Token token = PeekToken();
if (token.Kind == TokenKind.Equals)
{
token = NextToken();
SkipNewlines();
expr = ExpressionRule();
if (expr == null)
{
// ErrorRecovery: ?
IScriptExtent errorPosition = After(token);
ReportIncompleteInput(errorPosition, () => ParserStrings.MissingExpressionInNamedArgument);
expr = new ErrorExpressionAst(errorPosition);
SyncOnError(true, TokenKind.Comma, TokenKind.RParen, TokenKind.RBracket, TokenKind.NewLine);
}
lastItemExtent = expr.Extent;
}
else
{
// If the expression is missing, assume the value true
// and record that it was defaulted for better error messages.
expr = new ConstantExpressionAst(name.Extent, true);
expressionOmitted = true;
NoteV3FeatureUsed();
}
}
else
{
expr = ExpressionRule();
}
if (name != null)
{
if (keysSeen.Contains(name.Value))
{
// ErrorRecovery: this is a semantic error, so just keep parsing.
ReportError(name.Extent, () => ParserStrings.DuplicateNamedArgument, name.Value);
}
else
{
namedArguments.Add(new NamedAttributeArgumentAst(ExtentOf(name, expr),
name.Value, expr, expressionOmitted));
}
}
else if (expr != null)
{
positionalArguments.Add(expr);
lastItemExtent = expr.Extent;
}
else if (commaToken != null)
{
// ErrorRecovery: Pretend we saw the argument and keep going.
IScriptExtent errorExtent = After(commaToken);
ReportIncompleteInput(errorExtent, () => ParserStrings.MissingExpressionAfterToken,
commaToken.Kind.Text());
positionalArguments.Add(new ErrorExpressionAst(errorExtent));
lastItemExtent = errorExtent;
}
SkipNewlines();
commaToken = PeekToken();
if (commaToken.Kind != TokenKind.Comma)
{
break;
}
lastItemExtent = commaToken.Extent;
SkipToken();
}
}
finally
{
_disableCommaOperator = oldDisableCommaOperator;
}
}
/// <summary/>
public virtual object VisitConstantExpression(ConstantExpressionAst constantExpressionAst) { return null; }
/// <summary/>
public virtual object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return(null);
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return constantExpressionAst.Value;
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst ast)
{
return(CheckParent(ast));
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
// Constants are allowed.
return AstVisitAction.Continue;
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return(AstVisitAction.Continue);
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return(true);
}
public override AstVisitAction VisitConstantExpression(ConstantExpressionAst ast)
{
return this.Check(ast);
}
/// <summary/>
public virtual object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return _decorated.VisitConstantExpression(constantExpressionAst);
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
CheckIsConstant(constantExpressionAst, "Caller to verify ast is constant");
return constantExpressionAst.Value;
}
public System.Object VisitConstantExpression(System.Management.Automation.Language.ConstantExpressionAst constantExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(constantExpressionAst.Extent);
return(new ConstantExpressionAst(mappedExtent, constantExpressionAst.Value));
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
_visitCount++;
return true;
}
public virtual AstVisitAction VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return AstVisitAction.Continue;
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return Expression.Constant(constantExpressionAst.Value);
}
public void Setup()
{
this._constantExpressionAst = ParseStatement("1")
.PipelineElements[0]
.Expression;
}
public object VisitConstantExpression(ConstantExpressionAst constantExpressionAst)
{
return new CodePrimitiveExpression(constantExpressionAst.Value);
}
