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; }