private bool AstAssignsToSameVariable(Ast ast)
{
ParameterAst ast2 = ast as ParameterAst;
if (ast2 != null)
{
return(this.VariablePath.IsUnscopedVariable && ast2.Name.VariablePath.UnqualifiedPath.Equals(this.VariablePath.UnqualifiedPath, StringComparison.OrdinalIgnoreCase));
}
ForEachStatementAst ast3 = ast as ForEachStatementAst;
if (ast3 != null)
{
return(this.VariablePath.IsUnscopedVariable && ast3.Variable.VariablePath.UnqualifiedPath.Equals(this.VariablePath.UnqualifiedPath, StringComparison.OrdinalIgnoreCase));
}
AssignmentStatementAst ast4 = (AssignmentStatementAst)ast;
ExpressionAst left = ast4.Left;
ConvertExpressionAst ast6 = left as ConvertExpressionAst;
if (ast6 != null)
{
left = ast6.Child;
}
VariableExpressionAst ast7 = left as VariableExpressionAst;
if (ast7 == null)
{
return(false);
}
System.Management.Automation.VariablePath variablePath = ast7.VariablePath;
return(variablePath.UserPath.Equals(this.VariablePath.UserPath, StringComparison.OrdinalIgnoreCase) || (this.VariablePath.IsScript && this.VariablePath.UnqualifiedPath.Equals(variablePath.UnqualifiedPath, StringComparison.OrdinalIgnoreCase)));
}
private void CheckLHSAssign(ExpressionAst lhs, BitArray assignedBitArray)
{
ConvertExpressionAst ast = lhs as ConvertExpressionAst;
Type convertType = null;
if (ast != null)
{
lhs = ast.Child;
convertType = ast.StaticType;
}
VariableExpressionAst item = lhs as VariableExpressionAst;
VariablePath variablePath = item.VariablePath;
if (variablePath.IsAnyLocal())
{
string unaliasedVariableName = GetUnaliasedVariableName(variablePath);
if ((convertType == null) && (unaliasedVariableName.Equals("foreach", StringComparison.OrdinalIgnoreCase) || unaliasedVariableName.Equals("switch", StringComparison.OrdinalIgnoreCase)))
{
convertType = typeof(object);
}
VariableAnalysisDetails details = this.CheckLHSAssignVar(unaliasedVariableName, assignedBitArray, convertType);
details.AssociatedAsts.Add(item);
item.TupleIndex = details.LocalTupleIndex;
item.Automatic = details.Automatic;
}
else
{
item.TupleIndex = -2;
}
}
public System.Object VisitConvertExpression(System.Management.Automation.Language.ConvertExpressionAst convertExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(convertExpressionAst.Extent);
TypeConstraintAst mappedTypeConstraint = (TypeConstraintAst)VisitTypeConstraint(convertExpressionAst.Attribute as TypeConstraintAst);
ExpressionAst mappedChild = _VisitExpression(convertExpressionAst.Child);
return(new ConvertExpressionAst(mappedExtent, mappedTypeConstraint, mappedChild));
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
// at this point, we know we're safe because we checked both the type and the child,
// so now we can just call the compiler and indicate that it's trusted (at this point)
if (t_context == null)
{
throw PSTraceSource.NewArgumentException(nameof(convertExpressionAst));
}
return(Compiler.GetExpressionValue(convertExpressionAst, isTrustedInput: true, t_context, usingValues: null));
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
// at this point, we know we're safe because we checked both the type and the child,
// so now we can just call the compiler and indicate that it's trusted (at this point)
if (s_context != null)
{
return(Compiler.GetExpressionValue(convertExpressionAst, true, s_context, null));
}
else
{
throw PSTraceSource.NewArgumentException("ast");
}
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
Type reflectionType = convertExpressionAst.Type.TypeName.GetReflectionType();
if (reflectionType == null)
{
return(false);
}
if (!reflectionType.IsSafePrimitive())
{
return(false);
}
return((bool)convertExpressionAst.Child.Accept(this));
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
var type = convertExpressionAst.Type.TypeName.GetReflectionType();
if (type == null)
{
return(false);
}
if (!type.IsSafePrimitive())
{
// Only do conversions to built-in types - other conversions might not
// be safe to optimize.
return(false);
}
return((bool)convertExpressionAst.Child.Accept(this));
}
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 override AstVisitAction VisitConvertExpression(ConvertExpressionAst ast) { return CheckParent(ast); }
/// <summary/>
public virtual object VisitConvertExpression(ConvertExpressionAst convertExpressionAst) { return null; }
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
Type type = convertExpressionAst.Type.TypeName.GetReflectionType();
var value = EvaluateAst(convertExpressionAst.Child);
_pipelineCommandRuntime.WriteObject(LanguagePrimitives.ConvertTo(value, type));
return AstVisitAction.SkipChildren;
}
/// <summary>
/// Visit convert expression
/// </summary>
/// <param name="convertExpressionAst"></param>
/// <returns></returns>
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
if (convertExpressionAst == null) return null;
convertExpressionAst.Child.Visit(this.Decorator);
return null;
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return CompileAndInvoke(convertExpressionAst);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
Type reflectionType = convertExpressionAst.Type.TypeName.GetReflectionType();
if (reflectionType == null)
{
return false;
}
if (!reflectionType.IsSafePrimitive())
{
return false;
}
return (bool) convertExpressionAst.Child.Accept(this);
}
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);
}
internal override IEnumerable <PSTypeName> GetInferredType(CompletionContext context)
{
if (this.VariablePath.IsVariable)
{
Ast parent = this.Parent;
if (this.VariablePath.IsUnqualified && (this.VariablePath.UserPath.Equals("_", StringComparison.Ordinal) || this.VariablePath.UserPath.Equals("PSItem", StringComparison.OrdinalIgnoreCase)))
{
while (parent != null)
{
if (parent is ScriptBlockExpressionAst)
{
break;
}
parent = parent.Parent;
}
if (parent != null)
{
if ((parent.Parent is CommandExpressionAst) && (parent.Parent.Parent is PipelineAst))
{
if (parent.Parent.Parent.Parent is HashtableAst)
{
parent = parent.Parent.Parent.Parent;
}
else if ((parent.Parent.Parent.Parent is ArrayLiteralAst) && (parent.Parent.Parent.Parent.Parent is HashtableAst))
{
parent = parent.Parent.Parent.Parent.Parent;
}
}
if (parent.Parent is CommandParameterAst)
{
parent = parent.Parent;
}
CommandAst iteratorVariable1 = parent.Parent as CommandAst;
if (iteratorVariable1 != null)
{
PipelineAst iteratorVariable2 = (PipelineAst)iteratorVariable1.Parent;
int iteratorVariable3 = iteratorVariable2.PipelineElements.IndexOf(iteratorVariable1) - 1;
if (iteratorVariable3 >= 0)
{
foreach (PSTypeName iteratorVariable4 in iteratorVariable2.PipelineElements[0].GetInferredType(context))
{
if (iteratorVariable4.Type != null)
{
if (iteratorVariable4.Type.IsArray)
{
yield return(new PSTypeName(iteratorVariable4.Type.GetElementType()));
continue;
}
if (typeof(IEnumerable).IsAssignableFrom(iteratorVariable4.Type))
{
IEnumerable <Type> iteratorVariable5 = from t in iteratorVariable4.Type.GetInterfaces()
where t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(IEnumerable <>))
select t;
foreach (Type iteratorVariable6 in iteratorVariable5)
{
yield return(new PSTypeName(iteratorVariable6.GetGenericArguments()[0]));
}
continue;
}
}
yield return(iteratorVariable4);
}
}
goto Label_0833;
}
}
}
if (this.VariablePath.IsUnqualified)
{
for (int i = 0; i < SpecialVariables.AutomaticVariables.Length; i++)
{
if (this.VariablePath.UserPath.Equals(SpecialVariables.AutomaticVariables[i], StringComparison.OrdinalIgnoreCase))
{
Type type = SpecialVariables.AutomaticVariableTypes[i];
if (!type.Equals(typeof(object)))
{
yield return(new PSTypeName(type));
break;
}
break;
}
}
}
while (parent.Parent != null)
{
parent = parent.Parent;
}
if (parent.Parent is FunctionDefinitionAst)
{
parent = parent.Parent;
}
IEnumerable <Ast> source = AstSearcher.FindAll(parent, ast => (((ast is ParameterAst) || (ast is AssignmentStatementAst)) || (ast is ForEachStatementAst)) && this.AstAssignsToSameVariable(ast), true);
ParameterAst iteratorVariable10 = source.OfType <ParameterAst>().FirstOrDefault <ParameterAst>();
if (iteratorVariable10 != null)
{
PSTypeName[] iteratorVariable11 = iteratorVariable10.GetInferredType(context).ToArray <PSTypeName>();
if (iteratorVariable11.Length > 0)
{
foreach (PSTypeName iteratorVariable12 in iteratorVariable11)
{
yield return(iteratorVariable12);
}
goto Label_0833;
}
}
AssignmentStatementAst[] iteratorVariable13 = source.OfType <AssignmentStatementAst>().ToArray <AssignmentStatementAst>();
foreach (AssignmentStatementAst iteratorVariable14 in iteratorVariable13)
{
ConvertExpressionAst left = iteratorVariable14.Left as ConvertExpressionAst;
if ((left != null) && (left.StaticType != null))
{
yield return(new PSTypeName(left.StaticType));
goto Label_0833;
}
}
ForEachStatementAst iteratorVariable16 = source.OfType <ForEachStatementAst>().FirstOrDefault <ForEachStatementAst>();
if (iteratorVariable16 != null)
{
foreach (PSTypeName iteratorVariable17 in iteratorVariable16.Condition.GetInferredType(context))
{
yield return(iteratorVariable17);
}
}
else
{
int startOffset = this.Extent.StartOffset;
int iteratorVariable19 = 0x7fffffff;
AssignmentStatementAst iteratorVariable20 = null;
foreach (AssignmentStatementAst ast in iteratorVariable13)
{
int endOffset = ast.Extent.EndOffset;
if ((endOffset < startOffset) && ((startOffset - endOffset) < iteratorVariable19))
{
iteratorVariable19 = startOffset - endOffset;
iteratorVariable20 = ast;
}
}
if (iteratorVariable20 != null)
{
foreach (PSTypeName iteratorVariable21 in iteratorVariable20.Right.GetInferredType(context))
{
yield return(iteratorVariable21);
}
}
}
}
Label_0833:
yield break;
}
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 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;
}
/// <summary/>
public virtual object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return(null);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
object obj2;
if (!this.CompilingConstantExpression && IsConstantValueVisitor.IsConstant(convertExpressionAst, out obj2, false, false))
{
return Expression.Constant(obj2);
}
ITypeName typeName = convertExpressionAst.Type.TypeName;
HashtableAst child = convertExpressionAst.Child as HashtableAst;
Expression expression = null;
if (child != null)
{
ParameterExpression temp = this.NewTemp(typeof(OrderedDictionary), "orderedDictionary");
if (typeName.FullName.Equals("ordered", StringComparison.OrdinalIgnoreCase))
{
return Expression.Block(typeof(OrderedDictionary), new ParameterExpression[] { temp }, this.BuildHashtable(child.KeyValuePairs, temp, true));
}
if (typeName.FullName.Equals("PSCustomObject", StringComparison.OrdinalIgnoreCase))
{
expression = Expression.Block(typeof(OrderedDictionary), new ParameterExpression[] { temp }, this.BuildHashtable(child.KeyValuePairs, temp, true));
}
}
if (convertExpressionAst.IsRef())
{
VariableExpressionAst ast2 = convertExpressionAst.Child as VariableExpressionAst;
if (((ast2 != null) && ast2.VariablePath.IsVariable) && !ast2.IsConstantVariable())
{
IEnumerable<PropertyInfo> enumerable;
bool flag;
Type type = ast2.GetVariableType(this, out enumerable, out flag);
return Expression.Call(CachedReflectionInfo.VariableOps_GetVariableAsRef, Expression.Constant(ast2.VariablePath), _executionContextParameter, ((type != null) && !type.Equals(typeof(object))) ? Expression.Constant(type) : ExpressionCache.NullType);
}
}
if (expression == null)
{
expression = this.Compile(convertExpressionAst.Child);
}
if (typeName.FullName.Equals("PSCustomObject", StringComparison.OrdinalIgnoreCase))
{
return Expression.Dynamic(PSCustomObjectConverter.Get(), typeof(object), expression);
}
return ConvertValue(typeName, expression);
}
/// <summary/>
public virtual AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return(AstVisitAction.Continue);
}
/// <summary/> public virtual AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst) => DefaultVisit(convertExpressionAst);
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
// Convert is allowed if the type and child is allowed.
return AstVisitAction.Continue;
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
convertExpressionAst.Child.Accept(this);
return null;
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
if (convertExpressionAst.Type.TypeName.FullName.Equals(LanguagePrimitives.OrderedAttribute, StringComparison.OrdinalIgnoreCase))
{
if (!(convertExpressionAst.Child is HashtableAst))
{
// We allow the ordered attribute only on hashliteral node.
// This check covers the following scenario
// $a = [ordered]10
_parser.ReportError(convertExpressionAst.Extent, () => ParserStrings.OrderedAttributeOnlyOnHashLiteralNode, convertExpressionAst.Type.TypeName.FullName);
}
}
if (typeof(PSReference) == convertExpressionAst.Type.TypeName.GetReflectionType())
{
// Check for [ref][ref]
ExpressionAst child = convertExpressionAst.Child;
bool multipleRefs = false;
while (true)
{
var childAttrExpr = child as AttributedExpressionAst;
if (childAttrExpr != null)
{
var childConvert = childAttrExpr as ConvertExpressionAst;
if (childConvert != null && typeof(PSReference) == childConvert.Type.TypeName.GetReflectionType())
{
multipleRefs = true;
_parser.ReportError(childConvert.Type.Extent,
() => ParserStrings.ReferenceNeedsToBeByItselfInTypeSequence);
}
child = childAttrExpr.Child;
continue;
}
break;
}
// Check for [int][ref], but don't add an extra error for [ref][ref].
var parent = convertExpressionAst.Parent as AttributedExpressionAst;
while (parent != null)
{
var parentConvert = parent as ConvertExpressionAst;
if (parentConvert != null && !multipleRefs)
{
if (typeof(PSReference) == parentConvert.Type.TypeName.GetReflectionType())
{
break;
}
// Don't complain if on the lhs of an assign, there is a different error message, and
// that is checked as part of assignment.
var ast = parent.Parent;
bool skipError = false;
while (ast != null)
{
var statementAst = ast as AssignmentStatementAst;
if (statementAst != null)
{
skipError = statementAst.Left.Find(ast1 => ast1 == convertExpressionAst, searchNestedScriptBlocks: true) != null;
break;
}
if (ast is CommandExpressionAst)
{
break;
}
ast = ast.Parent;
}
if (!skipError)
{
_parser.ReportError(convertExpressionAst.Type.Extent,
() => ParserStrings.ReferenceNeedsToBeLastTypeInTypeConversion);
}
}
parent = parent.Child as AttributedExpressionAst;
}
}
// Converting to Type is suspicious
if (typeof(Type) == convertExpressionAst.Type.TypeName.GetReflectionType())
{
MarkAstParentsAsSuspicious(convertExpressionAst);
}
return AstVisitAction.Continue;
}
/// <summary/>
public virtual object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return _decorated.VisitConvertExpression(convertExpressionAst);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
throw new UnexpectedElementException();
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return(CompileAndInvoke(convertExpressionAst));
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
Type type = convertExpressionAst.Type.TypeName.GetReflectionType();
var value = EvaluateAst(convertExpressionAst.Child);
if (type.IsEnum)
{
var result = Enum.Parse(type, (string)value);
this._pipelineCommandRuntime.WriteObject(result);
return AstVisitAction.SkipChildren;
}
throw new NotImplementedException(); //VisitConvertExpression(convertExpressionAst);
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst ast)
{
return this.Check(ast);
}
public virtual AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return AstVisitAction.Continue;
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
return (bool) convertExpressionAst.Child.Accept(this);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
convertExpressionAst.Child.Accept(this);
return(null);
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
throw new NotImplementedException(); //VisitConvertExpression(convertExpressionAst);
}
private void CheckAssignmentTarget(ExpressionAst ast, bool simpleAssignment, Action <Ast> reportError)
{
ArrayLiteralAst ast2 = ast as ArrayLiteralAst;
Ast pipeline = null;
if (ast2 != null)
{
if (simpleAssignment)
{
this.CheckArrayLiteralAssignment(ast2, reportError);
}
else
{
pipeline = ast2;
}
}
else
{
ParenExpressionAst ast4 = ast as ParenExpressionAst;
if (ast4 != null)
{
ExpressionAst pureExpression = ast4.Pipeline.GetPureExpression();
if (pureExpression == null)
{
pipeline = ast4.Pipeline;
}
else
{
this.CheckAssignmentTarget(pureExpression, simpleAssignment, reportError);
}
}
else if (ast is ISupportsAssignment)
{
if (ast is AttributedExpressionAst)
{
ExpressionAst child = ast;
int num = 0;
IScriptExtent extent = null;
while (child is AttributedExpressionAst)
{
ConvertExpressionAst ast7 = child as ConvertExpressionAst;
if (ast7 != null)
{
num++;
Type reflectionType = ast7.Type.TypeName.GetReflectionType();
if (typeof(PSReference).Equals(reflectionType))
{
extent = ast7.Type.Extent;
}
else if (typeof(void).Equals(reflectionType))
{
this._parser.ReportError(ast7.Type.Extent, ParserStrings.VoidTypeConstraintNotAllowed, new object[0]);
}
}
child = ((AttributedExpressionAst)child).Child;
}
if ((extent != null) && (num > 1))
{
this._parser.ReportError(extent, ParserStrings.ReferenceNeedsToBeByItselfInTypeConstraint, new object[0]);
}
else
{
this.CheckAssignmentTarget(child, simpleAssignment, reportError);
}
}
}
else
{
pipeline = ast;
}
}
if (pipeline != null)
{
reportError(pipeline);
}
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
CheckIsConstant(convertExpressionAst, "Caller to verify ast is constant");
return CompileAndInvoke(convertExpressionAst);
}
public override AstVisitAction VisitConvertExpression(ConvertExpressionAst ast)
{
return(Check(ast));
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
var type = convertExpressionAst.Type.TypeName.GetReflectionType();
if (type == null)
{
return false;
}
if (!type.IsSafePrimitive())
{
// Only do conversions to built-in types - other conversions might not
// be safe to optimize.
return false;
}
_visitCount++;
return (bool)convertExpressionAst.Child.Accept(this);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
// at this point, we know we're safe because we checked both the type and the child,
// so now we can just call the compiler and indicate that it's trusted (at this point)
if (s_context != null)
{
return Compiler.GetExpressionValue(convertExpressionAst, true, s_context, null);
}
else
{
throw PSTraceSource.NewArgumentException("ast");
}
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
object constantValue;
if (!CompilingConstantExpression && IsConstantValueVisitor.IsConstant(convertExpressionAst, out constantValue))
{
return Expression.Constant(constantValue);
}
var typeName = convertExpressionAst.Type.TypeName;
var hashTableAst = convertExpressionAst.Child as HashtableAst;
Expression childExpr = null;
if (hashTableAst != null)
{
var temp = NewTemp(typeof(OrderedDictionary), "orderedDictionary");
if (typeName.FullName.Equals(LanguagePrimitives.OrderedAttribute, StringComparison.OrdinalIgnoreCase))
{
return Expression.Block(typeof(OrderedDictionary),
new[] { temp },
BuildHashtable(hashTableAst.KeyValuePairs, temp, ordered: true));
}
if (typeName.FullName.Equals("PSCustomObject", StringComparison.OrdinalIgnoreCase))
{
// pure laziness here - we should construct the PSObject directly. Instead, we're relying on the conversion
// to create the PSObject from an OrderedDictionary.
childExpr = Expression.Block(typeof(OrderedDictionary),
new[] { temp },
BuildHashtable(hashTableAst.KeyValuePairs, temp, ordered: true));
}
}
if (convertExpressionAst.IsRef())
{
var varExpr = convertExpressionAst.Child as VariableExpressionAst;
if (varExpr != null && varExpr.VariablePath.IsVariable && !varExpr.IsConstantVariable())
{
// We'll wrap the variable in a PSReference, but not the constant variables ($true, $false, $null) because those
// can't be changed.
IEnumerable<PropertyInfo> unused1;
bool unused2;
var varType = varExpr.GetVariableType(this, out unused1, out unused2);
return Expression.Call(CachedReflectionInfo.VariableOps_GetVariableAsRef,
Expression.Constant(varExpr.VariablePath), _executionContextParameter,
varType != null && varType != typeof(object)
? Expression.Constant(varType, typeof(Type))
: ExpressionCache.NullType);
}
}
if (childExpr == null)
{
childExpr = Compile(convertExpressionAst.Child);
}
if (typeName.FullName.Equals("PSCustomObject", StringComparison.OrdinalIgnoreCase))
{
// We can't use the normal PSConvertBinder because it is strongly typed, and we
// play some funny games with the PSCustomObject type (externally, it's just an
// alias for PSObject, internally we do other stuff with it.)
return DynamicExpression.Dynamic(PSCustomObjectConverter.Get(), typeof(object), childExpr);
}
return ConvertValue(convertExpressionAst.Type, childExpr);
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
CheckIsConstant(convertExpressionAst, "Caller to verify ast is constant");
return(CompileAndInvoke(convertExpressionAst));
}
public object VisitConvertExpression(ConvertExpressionAst convertExpressionAst)
{
if (_currentMethod == null)
{
var typeName = convertExpressionAst.Type.TypeName.FullName;
var refExp = Visit(convertExpressionAst.Child) as CodeVariableReferenceExpression;
if (refExp != null)
{
_currentClass.Members.Add(new CodeMemberField(typeName, refExp.VariableName));
}
}
return null;
}
