public System.Object VisitAttributedExpression(System.Management.Automation.Language.AttributedExpressionAst attributedExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(attributedExpressionAst.Extent);
AttributeBaseAst mappedAttribute = _VisitAttributeBase(attributedExpressionAst.Attribute);
ExpressionAst mappedChild = _VisitExpression(attributedExpressionAst.Child);
return(new AttributedExpressionAst(mappedExtent, mappedAttribute, mappedChild));
}
private ISupportsAssignment GetActualAssignableAst()
{
ExpressionAst child = this;
for (AttributedExpressionAst ast2 = child as AttributedExpressionAst; ast2 != null; ast2 = child as AttributedExpressionAst)
{
child = ast2.Child;
}
return((ISupportsAssignment)child);
}
private List <AttributeBaseAst> GetAttributes()
{
List <AttributeBaseAst> list = new List <AttributeBaseAst>();
for (AttributedExpressionAst ast = this; ast != null; ast = ast.Child as AttributedExpressionAst)
{
list.Add(ast.Attribute);
}
list.Reverse();
return(list);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
AttributeBaseAst attribute = attributedExpressionAst.Attribute;
while (attributedExpressionAst != null)
{
if (attributedExpressionAst.Child is VariableExpressionAst)
{
return(AstVisitAction.Continue);
}
attributedExpressionAst = attributedExpressionAst.Child as AttributedExpressionAst;
}
this._parser.ReportError(attribute.Extent, ParserStrings.UnexpectedAttribute, new object[] { attribute.TypeName.FullName });
return(AstVisitAction.Continue);
}
/// <summary/>
public virtual object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return _decorated.VisitAttributedExpression(attributedExpressionAst);
}
private ExpressionAst UnaryExpressionRule()
{
//G unary-expression:
//G primary-expression
//G expression-with-unary-operator
//G
//G expression-with-unary-operator:
//G ',' new-lines:opt unary-expression
//G '-not' new-lines:opt unary-expression
//G '!' new-lines:opt unary-expression
//G '-bnot' new-lines:opt unary-expression
//G '+' new-lines:opt unary-expression
//G dash new-lines:opt unary-expression
//G pre-increment-expression
//G pre-decrement-expression
//G cast-expression
//G '-split' new-lines:opt unary-expression
//G '-join' new-lines:opt unary-expression
//G
//G pre-increment-expression:
//G '++' new-lines:opt unary-expression
//G
//G pre-decrement-expression:
//G dashdash new-lines:opt unary-expression
//G
//G cast-expression:
//G type-literal unary-expression
RuntimeHelpers.EnsureSufficientExecutionStack();
ExpressionAst expr = null;
Token token;
bool oldAllowSignedNumbers = _tokenizer.AllowSignedNumbers;
try
{
_tokenizer.AllowSignedNumbers = true;
if (_ungotToken != null && _ungotToken.Kind == TokenKind.Minus)
{
Resync(_ungotToken);
}
token = PeekToken();
}
finally
{
_tokenizer.AllowSignedNumbers = oldAllowSignedNumbers;
}
ExpressionAst child;
if (token.Kind.HasTrait(TokenFlags.UnaryOperator))
{
if (_disableCommaOperator && token.Kind == TokenKind.Comma)
{
return null;
}
SkipToken();
SkipNewlines();
child = UnaryExpressionRule();
if (child != null)
{
if (token.Kind == TokenKind.Comma)
{
expr = new ArrayLiteralAst(ExtentOf(token, child), new ExpressionAst[] { child });
}
else
{
expr = new UnaryExpressionAst(ExtentOf(token, child), token.Kind, child);
}
}
else
{
// ErrorRecovery: don't bother constructing a unary expression, but we know we must have
// some sort of expression, so return an error expression.
// Use token.Text, not token.Kind.Text() b/c the kind might not match the actual operator used
// when a case insensitive operator is used.
ReportIncompleteInput(After(token), () => ParserStrings.MissingExpressionAfterOperator, token.Text);
return new ErrorExpressionAst(token.Extent);
}
}
else if (token.Kind == TokenKind.LBracket)
{
// Possibly a type literal or attribute.
var attributes = AttributeListRule(true);
if (attributes == null)
{
return null;
}
AttributeBaseAst lastAttribute = attributes.Last();
if (lastAttribute is AttributeAst)
{
SkipNewlines();
child = UnaryExpressionRule();
if (child == null)
{
// ErrorRecovery: We have a list of attributes, and we know it's not before a param statement,
// so we know we must have some sort of expression. Return an error expression then.
ReportIncompleteInput(lastAttribute.Extent,
() => ParserStrings.UnexpectedAttribute, lastAttribute.TypeName.FullName);
return new ErrorExpressionAst(ExtentOf(token, lastAttribute));
}
expr = new AttributedExpressionAst(ExtentOf(lastAttribute, child), lastAttribute, child);
}
else
{
Diagnostics.Assert(_ungotToken == null || ErrorList.Count > 0,
"Unexpected lookahead from AttributeListRule.");
// If we've looked ahead, don't go looking for a member access token, we've already issued an error,
// just assume we're not trying to access a member.
var memberAccessToken = _ungotToken != null ? null : NextMemberAccessToken(false);
if (memberAccessToken != null)
{
expr = CheckPostPrimaryExpressionOperators(memberAccessToken,
new TypeExpressionAst(lastAttribute.Extent,
lastAttribute.TypeName));
}
else
{
token = PeekToken();
if (token.Kind != TokenKind.NewLine && token.Kind != TokenKind.Comma)
{
child = UnaryExpressionRule();
if (child != null)
{
expr = new ConvertExpressionAst(ExtentOf(lastAttribute, child),
(TypeConstraintAst)lastAttribute, child);
}
}
}
if (expr == null)
{
expr = new TypeExpressionAst(lastAttribute.Extent, lastAttribute.TypeName);
}
}
for (int i = attributes.Count - 2; i >= 0; --i)
{
var typeConstraint = attributes[i] as TypeConstraintAst;
expr = typeConstraint != null
? new ConvertExpressionAst(ExtentOf(typeConstraint, expr), typeConstraint, expr)
: new AttributedExpressionAst(ExtentOf(attributes[i], expr), attributes[i], expr);
}
}
else
{
expr = PrimaryExpressionRule(withMemberAccess: true);
}
if (expr != null)
{
token = PeekToken();
TokenKind operation = (token.Kind == TokenKind.PlusPlus)
? TokenKind.PostfixPlusPlus
: (token.Kind == TokenKind.MinusMinus)
? TokenKind.PostfixMinusMinus
: TokenKind.Unknown;
if (operation != TokenKind.Unknown)
{
SkipToken();
expr = new UnaryExpressionAst(ExtentOf(expr, token), operation, expr);
}
}
return expr;
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return(false);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst ast) { return CheckParent(ast); }
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst ast)
{
return(Check(ast));
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
attributedExpressionAst.Child.Accept(this);
return(null);
}
private ExpressionAst UnaryExpressionRule()
{
Token token;
ExpressionAst expressionAst;
TokenKind tokenKind;
Token token1;
ExpressionAst convertExpressionAst;
RuntimeHelpers.EnsureSufficientExecutionStack();
ExpressionAst typeExpressionAst = null;
bool allowSignedNumbers = this._tokenizer.AllowSignedNumbers;
try
{
this._tokenizer.AllowSignedNumbers = true;
if (this._ungotToken != null && this._ungotToken.Kind == TokenKind.Minus)
{
this.Resync(this._ungotToken);
}
token = this.PeekToken();
}
finally
{
this._tokenizer.AllowSignedNumbers = allowSignedNumbers;
}
if (!token.Kind.HasTrait(TokenFlags.UnaryOperator))
{
if (token.Kind != TokenKind.LBracket)
{
typeExpressionAst = this.PrimaryExpressionRule(true);
}
else
{
List<AttributeBaseAst> attributeBaseAsts = this.AttributeListRule(true);
if (attributeBaseAsts != null)
{
AttributeBaseAst attributeBaseAst = attributeBaseAsts.Last<AttributeBaseAst>();
if (attributeBaseAst as AttributeAst == null)
{
if (this._ungotToken != null)
{
token1 = null;
}
else
{
token1 = this.NextMemberAccessToken(false);
}
Token token2 = token1;
if (token2 == null)
{
token = this.PeekToken();
if (token.Kind != TokenKind.NewLine && token.Kind != TokenKind.Comma)
{
expressionAst = this.UnaryExpressionRule();
if (expressionAst != null)
{
typeExpressionAst = new ConvertExpressionAst(Parser.ExtentOf(attributeBaseAst, expressionAst), (TypeConstraintAst)attributeBaseAst, expressionAst);
}
}
}
else
{
typeExpressionAst = this.CheckPostPrimaryExpressionOperators(token2, new TypeExpressionAst(attributeBaseAst.Extent, attributeBaseAst.TypeName));
}
if (typeExpressionAst == null)
{
typeExpressionAst = new TypeExpressionAst(attributeBaseAst.Extent, attributeBaseAst.TypeName);
}
}
else
{
this.SkipNewlines();
expressionAst = this.UnaryExpressionRule();
if (expressionAst != null)
{
typeExpressionAst = new AttributedExpressionAst(Parser.ExtentOf(attributeBaseAst, expressionAst), attributeBaseAst, expressionAst);
}
else
{
object[] fullName = new object[1];
fullName[0] = attributeBaseAst.TypeName.FullName;
this.ReportIncompleteInput(attributeBaseAst.Extent, ParserStrings.UnexpectedAttribute, fullName);
return new ErrorExpressionAst(Parser.ExtentOf(token, attributeBaseAst), null);
}
}
for (int i = attributeBaseAsts.Count - 2; i >= 0; i--)
{
TypeConstraintAst item = attributeBaseAsts[i] as TypeConstraintAst;
if (item != null)
{
convertExpressionAst = new ConvertExpressionAst(Parser.ExtentOf(item, typeExpressionAst), item, typeExpressionAst);
}
else
{
convertExpressionAst = new AttributedExpressionAst(Parser.ExtentOf(attributeBaseAsts[i], typeExpressionAst), attributeBaseAsts[i], typeExpressionAst);
}
typeExpressionAst = convertExpressionAst;
}
}
else
{
return null;
}
}
}
else
{
if (!this._disableCommaOperator || token.Kind != TokenKind.Comma)
{
this.SkipToken();
this.SkipNewlines();
expressionAst = this.UnaryExpressionRule();
if (expressionAst == null)
{
object[] text = new object[1];
text[0] = token.Text;
this.ReportIncompleteInput(Parser.After(token), ParserStrings.MissingExpressionAfterOperator, text);
return new ErrorExpressionAst(token.Extent, null);
}
else
{
if (token.Kind != TokenKind.Comma)
{
typeExpressionAst = new UnaryExpressionAst(Parser.ExtentOf(token, expressionAst), token.Kind, expressionAst);
}
else
{
ExpressionAst[] expressionAstArray = new ExpressionAst[1];
expressionAstArray[0] = expressionAst;
typeExpressionAst = new ArrayLiteralAst(Parser.ExtentOf(token, expressionAst), expressionAstArray);
}
}
}
else
{
return null;
}
}
if (typeExpressionAst != null)
{
token = this.PeekToken();
if (token.Kind == TokenKind.PlusPlus)
{
tokenKind = TokenKind.PostfixPlusPlus;
}
else
{
if (token.Kind == TokenKind.MinusMinus)
{
tokenKind = TokenKind.PostfixMinusMinus;
}
else
{
tokenKind = TokenKind.Unknown;
}
}
TokenKind tokenKind1 = tokenKind;
if (tokenKind1 != TokenKind.Unknown)
{
this.SkipToken();
typeExpressionAst = new UnaryExpressionAst(Parser.ExtentOf(typeExpressionAst, token), tokenKind1, typeExpressionAst);
}
}
return typeExpressionAst;
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst) { throw new UnexpectedElementException(); }
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
throw new NotImplementedException(); //VisitAttributedExpression(attributedExpressionAst);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
// Attributes are not allowed, they may code in attribute constructors.
ReportError(attributedExpressionAst, () => ParserStrings.AttributeNotSupportedInDataSection);
return AstVisitAction.Continue;
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
// The attribute (and not the entire expression) is used for the error extent.
var errorAst = attributedExpressionAst.Attribute;
while (attributedExpressionAst != null)
{
if (attributedExpressionAst.Child is VariableExpressionAst)
{
return AstVisitAction.Continue;
}
attributedExpressionAst = attributedExpressionAst.Child as AttributedExpressionAst;
}
_parser.ReportError(errorAst.Extent, () => ParserStrings.UnexpectedAttribute, errorAst.TypeName.FullName);
return AstVisitAction.Continue;
}
/// <summary/> public virtual AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst) => DefaultVisit(attributedExpressionAst);
/// <summary/>
public virtual object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst) { return null; }
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
Func <Ast, bool> predicate = null;
if (convertExpressionAst.Type.TypeName.FullName.Equals("ordered", StringComparison.OrdinalIgnoreCase) && !(convertExpressionAst.Child is HashtableAst))
{
this._parser.ReportError(convertExpressionAst.Extent, ParserStrings.OrderedAttributeOnlyOnHashLiteralNode, new object[] { convertExpressionAst.Type.TypeName.FullName });
}
if (typeof(PSReference).Equals(convertExpressionAst.Type.TypeName.GetReflectionType()))
{
ExpressionAst child = convertExpressionAst.Child;
bool flag = false;
while (true)
{
AttributedExpressionAst ast2 = child as AttributedExpressionAst;
if (ast2 == null)
{
break;
}
ConvertExpressionAst ast3 = ast2 as ConvertExpressionAst;
if ((ast3 != null) && typeof(PSReference).Equals(ast3.Type.TypeName.GetReflectionType()))
{
flag = true;
this._parser.ReportError(ast3.Type.Extent, ParserStrings.ReferenceNeedsToBeByItselfInTypeSequence, new object[0]);
}
child = ast2.Child;
}
for (AttributedExpressionAst ast4 = convertExpressionAst.Parent as AttributedExpressionAst; ast4 != null; ast4 = ast4.Child as AttributedExpressionAst)
{
ConvertExpressionAst ast5 = ast4 as ConvertExpressionAst;
if ((ast5 != null) && !flag)
{
if (typeof(PSReference).Equals(ast5.Type.TypeName.GetReflectionType()))
{
break;
}
Ast parent = ast4.Parent;
bool flag2 = false;
while (parent != null)
{
if (parent is AssignmentStatementAst)
{
if (predicate == null)
{
predicate = ast1 => ast1 == convertExpressionAst;
}
flag2 = ((AssignmentStatementAst)parent).Left.Find(predicate, true) != null;
break;
}
if (parent is CommandExpressionAst)
{
break;
}
parent = parent.Parent;
}
if (!flag2)
{
this._parser.ReportError(convertExpressionAst.Type.Extent, ParserStrings.ReferenceNeedsToBeLastTypeInTypeConversion, new object[0]);
}
}
}
}
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
this.ReportError(attributedExpressionAst, () => ParserStrings.AttributeNotSupportedInDataSection, new object[0]);
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
AttributeBaseAst attribute = attributedExpressionAst.Attribute;
while (attributedExpressionAst != null)
{
if (attributedExpressionAst.Child is VariableExpressionAst)
{
return AstVisitAction.Continue;
}
attributedExpressionAst = attributedExpressionAst.Child as AttributedExpressionAst;
}
this._parser.ReportError(attribute.Extent, ParserStrings.UnexpectedAttribute, new object[] { attribute.TypeName.FullName });
return AstVisitAction.Continue;
}
public virtual AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst ast)
{
return this.Check(ast);
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst) { return AutomationNull.Value; }
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst) { throw PSTraceSource.NewArgumentException("ast"); }
/// <summary/>
public virtual object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return(null);
}
public override AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
this.ReportError(attributedExpressionAst, () => ParserStrings.AttributeNotSupportedInDataSection, new object[0]);
return AstVisitAction.Continue;
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return false;
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
attributedExpressionAst.Child.Accept(this);
return null;
}
/// <summary/>
public virtual AstVisitAction VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return(AstVisitAction.Continue);
}
/// <summary>
/// Visit Attributed Expression
/// </summary>
/// <param name="attributedExpressionAst"></param>
/// <returns></returns>
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
if (attributedExpressionAst == null) return null;
attributedExpressionAst.Child.Visit(this.Decorator);
return null;
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
return(AutomationNull.Value);
}
public object VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)
{
throw new NotImplementedException();
}