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))); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { if (parameterAst.Name.VariablePath.IsAnyLocal()) { this._validVariables.Add(parameterAst.Name.VariablePath.UnqualifiedPath); } return AstVisitAction.Continue; }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { foreach (AttributeBaseAst ast in parameterAst.Attributes) { if ((ast is TypeConstraintAst) && ast.TypeName.FullName.Equals("ordered", StringComparison.OrdinalIgnoreCase)) { this._parser.ReportError(ast.Extent, ParserStrings.OrderedAttributeOnlyOnHashLiteralNode, new object[] { ast.TypeName.FullName }); } } return(AstVisitAction.Continue); }
public System.Object VisitParameter(System.Management.Automation.Language.ParameterAst parameterAst) { IScriptExtent mappedExtent = MapExtent(parameterAst.Extent); VariableExpressionAst mappedName = (VariableExpressionAst)VisitVariableExpression(parameterAst.Name); LinkedList <AttributeBaseAst> mappedAttributes = new LinkedList <AttributeBaseAst>(); foreach (AttributeBaseAst ab in parameterAst.Attributes) { mappedAttributes.AddLast(_VisitAttributeBase(ab)); } ExpressionAst mappedDefaultValue = parameterAst.DefaultValue != null?_VisitExpression(parameterAst.DefaultValue) : null; return(new ParameterAst(mappedExtent, mappedName, mappedAttributes, mappedDefaultValue)); }
public virtual AstVisitAction VisitParameter(ParameterAst parameterAst) { return AstVisitAction.Continue; }
private void BindVariable(ParameterAst scriptParameter, CommandParameter argument) { var value = GetParameterValue(scriptParameter, argument); _executionContext.SetVariable(scriptParameter.Name.VariablePath.UserPath, value); }
/// <summary/> public virtual object VisitParameter(ParameterAst parameterAst) { return _decorated.VisitParameter(parameterAst); }
private object GetParameterValue(ParameterAst scriptParameter, CommandParameter parameter) { if (parameter != null) { return parameter.Value; } return GetDefaultParameterValue(scriptParameter); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { foreach (AttributeBaseAst ast in parameterAst.Attributes) { if ((ast is TypeConstraintAst) && ast.TypeName.FullName.Equals("ordered", StringComparison.OrdinalIgnoreCase)) { this._parser.ReportError(ast.Extent, ParserStrings.OrderedAttributeOnlyOnHashLiteralNode, new object[] { ast.TypeName.FullName }); } } return AstVisitAction.Continue; }
public object VisitParameter(ParameterAst parameterAst) { return null; }
// We assume they have the same name private bool CompareParamAsts(ParameterAst paramAst1, ParameterAst paramAst2) { if (paramAst1.StaticType != paramAst2.StaticType) { return false; } if ((paramAst1.Attributes == null && paramAst2.Attributes != null) || (paramAst1.Attributes != null && paramAst2.Attributes == null)) { return false; } if (paramAst1.Attributes != null && paramAst2.Attributes != null) { if (paramAst1.Attributes.Count() != paramAst2.Attributes.Count()) { return false; } HashSet<string> attributes = new HashSet<string>(StringComparer.OrdinalIgnoreCase); foreach (var attribute in paramAst1.Attributes) { attributes.Add(attribute.TypeName.FullName); } foreach (var attribute in paramAst2.Attributes) { if (!attributes.Contains(attribute.TypeName.FullName)) { return false; } } } return true; }
public object VisitParameter(ParameterAst parameterAst) { throw PSTraceSource.NewArgumentException("ast"); }
private static RuntimeDefinedParameter GetRuntimeDefinedParameter(ParameterAst parameterAst, ref bool customParameterSet, ref bool usesCmdletBinding) { object obj3; List<Attribute> list = new List<Attribute>(); bool flag = false; foreach (AttributeBaseAst ast in parameterAst.Attributes) { Attribute item = ast.GetAttribute(); list.Add(item); ParameterAttribute attribute2 = item as ParameterAttribute; if (attribute2 != null) { flag = true; usesCmdletBinding = true; if ((attribute2.Position != -2147483648) || !attribute2.ParameterSetName.Equals("__AllParameterSets", StringComparison.OrdinalIgnoreCase)) { customParameterSet = true; } } } list.Reverse(); if (!flag) { list.Insert(0, new ParameterAttribute()); } RuntimeDefinedParameter parameter = new RuntimeDefinedParameter(parameterAst.Name.VariablePath.UserPath, parameterAst.StaticType, new Collection<Attribute>(list.ToArray())); if (parameterAst.DefaultValue != null) { object obj2; if (IsConstantValueVisitor.IsConstant(parameterAst.DefaultValue, out obj2, false, false)) { parameter.Value = obj2; return parameter; } DefaultValueExpressionWrapper wrapper = new DefaultValueExpressionWrapper { Expression = parameterAst.DefaultValue }; parameter.Value = wrapper; return parameter; } if (TryGetDefaultParameterValue(parameterAst.StaticType, out obj3) && (obj3 != null)) { parameter.Value = obj3; } return parameter; }
private ParameterAst ParameterRule() { ParameterAst parameterAst; IScriptExtent extent; IScriptExtent scriptExtent; ExpressionAst expressionAst = null; bool flag = this._disableCommaOperator; TokenizerMode mode = this._tokenizer.Mode; try { this._disableCommaOperator = true; this.SetTokenizerMode(TokenizerMode.Expression); this.SkipNewlines(); List<AttributeBaseAst> attributeBaseAsts = this.AttributeListRule(false); this.SkipNewlines(); Token token = this.NextToken(); if (token.Kind == TokenKind.Variable || token.Kind == TokenKind.SplattedVariable) { VariableToken variableToken = (VariableToken)token; this.SkipNewlines(); Token token1 = this.PeekToken(); if (token1.Kind == TokenKind.Equals) { this.SkipToken(); this.SkipNewlines(); expressionAst = this.ExpressionRule(); if (expressionAst == null) { object[] objArray = new object[1]; objArray[0] = token1.Kind.Text(); this.ReportIncompleteInput(Parser.After(token1), ParserStrings.MissingExpressionAfterToken, objArray); } } if (attributeBaseAsts == null) { extent = variableToken.Extent; } else { extent = attributeBaseAsts[0].Extent; } IScriptExtent scriptExtent1 = extent; if (expressionAst == null) { scriptExtent = variableToken.Extent; } else { scriptExtent = expressionAst.Extent; } IScriptExtent scriptExtent2 = scriptExtent; return new ParameterAst(Parser.ExtentOf(scriptExtent1, scriptExtent2), new VariableExpressionAst(variableToken), attributeBaseAsts, expressionAst); } else { this.UngetToken(token); if (attributeBaseAsts == null) { parameterAst = null; } else { this.ReportIncompleteInput(Parser.After(attributeBaseAsts.Last<AttributeBaseAst>()), ParserStrings.InvalidFunctionParameter, new object[0]); TokenKind[] tokenKindArray = new TokenKind[1]; tokenKindArray[0] = TokenKind.RParen; this.SyncOnError(tokenKindArray); IScriptExtent scriptExtent3 = Parser.ExtentOf(attributeBaseAsts[0].Extent, attributeBaseAsts[attributeBaseAsts.Count - 1].Extent); parameterAst = new ParameterAst(scriptExtent3, new VariableExpressionAst(scriptExtent3, "__error__", false), attributeBaseAsts, null); } } } finally { this._disableCommaOperator = flag; this.SetTokenizerMode(mode); } return parameterAst; }
private TypeConstraintAst GetTypeAttributeAst(ParameterAst paramAst) { if (paramAst.Attributes != null) { foreach(var attr in paramAst.Attributes) { if (attr.GetType() == typeof(TypeConstraintAst)) { return attr as TypeConstraintAst; } } } return null; }
private List<CorrectionExtent> GetCorrectionExtent(ParameterAst paramAst) { //Find the parameter type extent and replace that with secure string IScriptExtent extent; var typeAttributeAst = GetTypeAttributeAst(paramAst); var corrections = new List<CorrectionExtent>(); string correctionText; if (typeAttributeAst == null) { // cannot find any type attribute extent = paramAst.Name.Extent; correctionText = string.Format("[SecureString] {0}", paramAst.Name.Extent.Text); } else { // replace only the existing type with [SecureString] extent = typeAttributeAst.Extent; correctionText = typeAttributeAst.TypeName.IsArray ? "[SecureString[]]" : "[SecureString]"; } string description = string.Format( CultureInfo.CurrentCulture, Strings.AvoidUsingPlainTextForPasswordCorrectionDescription, paramAst.Name.Extent.Text); corrections.Add(new CorrectionExtent( extent.StartLineNumber, extent.EndLineNumber, extent.StartColumnNumber, extent.EndColumnNumber, correctionText.ToString(), paramAst.Extent.File, description)); return corrections; }
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; }
public override AstVisitAction VisitParameter(ParameterAst ast) { return(Check(ast)); }
/// <summary/> public virtual AstVisitAction VisitParameter(ParameterAst parameterAst) => DefaultVisit(parameterAst);
public object VisitParameter(ParameterAst parameterAst) { return(false); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { Diagnostics.Assert(FoundError, "VisitParamBlock or VisitFunctionDeclaration should have already reported an error"); return AstVisitAction.Continue; }
/// <summary> /// Returns script extent of username and password parameters /// </summary> /// <param name="usernameAst"></param> /// <param name="passwordAst"></param> /// <returns>IScriptExtent</returns> private IScriptExtent GetExtent(ParameterAst usernameAst, ParameterAst passwordAst, Ast scriptAst) { var usrExt = usernameAst.Extent; var pwdExt = passwordAst.Extent; IScriptExtent startExt, endExt; var usrBeforePwd = (usrExt.StartLineNumber == pwdExt.StartLineNumber && usrExt.StartColumnNumber < pwdExt.StartColumnNumber) || usrExt.StartLineNumber < pwdExt.StartLineNumber; if (usrBeforePwd) { startExt = usrExt; endExt = pwdExt; } else { startExt = pwdExt; endExt = usrExt; } var startPos = new ScriptPosition( startExt.File, startExt.StartLineNumber, startExt.StartColumnNumber, startExt.StartScriptPosition.Line); var endPos = new ScriptPosition( endExt.File, endExt.EndLineNumber, endExt.EndColumnNumber, endExt.EndScriptPosition.Line); return new ScriptExtent(startPos, endPos); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { bool isClassMethod = parameterAst.Parent.Parent is FunctionMemberAst; bool isParamTypeDefined = false; foreach (AttributeBaseAst attribute in parameterAst.Attributes) { if (attribute is TypeConstraintAst) { if (attribute.TypeName.FullName.Equals(LanguagePrimitives.OrderedAttribute, StringComparison.OrdinalIgnoreCase)) { _parser.ReportError(attribute.Extent, () => ParserStrings.OrderedAttributeOnlyOnHashLiteralNode, attribute.TypeName.FullName); } else { if (isClassMethod) { // attribute represent parameter type. if (isParamTypeDefined) { _parser.ReportError(attribute.Extent, () => ParserStrings.MultipleTypeConstraintsOnMethodParam); } isParamTypeDefined = true; } } } } return AstVisitAction.Continue; }
/// <summary> /// Visit parameter /// </summary> /// <param name="parameterAst"></param> /// <returns></returns> public object VisitParameter(ParameterAst parameterAst) { // Nothing to do now, we've already allocated parameters in the first pass looking for all variable names. System.Diagnostics.Debug.Assert(false, "Code is unreachable"); return null; }
internal string ToStringForSerialization(Tuple <List <VariableExpressionAst>, string> usingVariablesTuple, int initialStartOffset, int initialEndOffset) { List <VariableExpressionAst> collection = usingVariablesTuple.Item1; string str = usingVariablesTuple.Item2; List <Ast> list2 = new List <Ast>(collection); if (this.ParamBlock != null) { list2.Add(this.ParamBlock); } int startOffset = base.Extent.StartOffset; int startIndex = initialStartOffset - startOffset; int num3 = initialEndOffset - startOffset; string str2 = this.ToString(); StringBuilder builder = new StringBuilder(); foreach (Ast ast in from ast in list2 orderby ast.Extent.StartOffset select ast) { int num4 = ast.Extent.StartOffset - startOffset; int num5 = ast.Extent.EndOffset - startOffset; if (num4 >= startIndex) { if (num4 >= num3) { break; } VariableExpressionAst ast2 = ast as VariableExpressionAst; if (ast2 != null) { string userPath = ast2.VariablePath.UserPath; string str4 = ast2.Splatted ? "@" : "$"; string str5 = str4 + "__using_" + userPath; builder.Append(str2.Substring(startIndex, num4 - startIndex)); builder.Append(str5); startIndex = num5; } else { int num6; ParamBlockAst ast3 = ast as ParamBlockAst; if (ast3.Parameters.Count == 0) { num6 = num5 - 1; } else { ParameterAst ast4 = ast3.Parameters[0]; num6 = (ast4.Attributes.Count == 0) ? (ast4.Name.Extent.StartOffset - startOffset) : (ast4.Attributes[0].Extent.StartOffset - startOffset); str = str + ",\n"; } builder.Append(str2.Substring(startIndex, num6 - startIndex)); builder.Append(str); startIndex = num6; } } } builder.Append(str2.Substring(startIndex, num3 - startIndex)); string str6 = builder.ToString(); if (((base.Parent is ScriptBlockExpressionAst) && (initialStartOffset == base.Extent.StartOffset)) && (initialEndOffset == base.Extent.EndOffset)) { str6 = str6.Substring(1, str6.Length - 2); } return(str6); }
private bool WrongCredentialUsage(ParameterAst parameter) { if (parameter.Name.VariablePath.UserPath.Equals("Credential", StringComparison.OrdinalIgnoreCase)) { var psCredentialType = parameter.Attributes.FirstOrDefault(paramAttribute => (paramAttribute.TypeName.IsArray && (paramAttribute.TypeName as ArrayTypeName).ElementType.GetReflectionType() == typeof(PSCredential)) || paramAttribute.TypeName.GetReflectionType() == typeof(PSCredential)); var credentialAttribute = parameter.Attributes.FirstOrDefault(paramAttribute => paramAttribute.TypeName.GetReflectionType() == typeof(CredentialAttribute)); // check that both exists and pscredentialtype comes before credential attribute if (psCredentialType != null && credentialAttribute != null && psCredentialType.Extent.EndOffset < credentialAttribute.Extent.StartOffset) { return false; } return true; } return false; }
private object GetParameterValue(ParameterAst scriptParameter, CommandParameter parameter) { if (parameter != null) { return parameter.Value; } return _scopedExecutionVisitor.EvaluateAst(scriptParameter.DefaultValue);; }
private object GetDefaultParameterValue(ParameterAst scriptParameter) { var constantExpression = scriptParameter.DefaultValue as ConstantExpressionAst; if (constantExpression != null) { return constantExpression.Value; } return null; }
public object VisitParameter(ParameterAst parameterAst) { throw new UnexpectedElementException(); }
private object GetParameterValue(ParameterAst scriptParameter, CommandParameter argument) { if (argument != null) { return argument.Value; } if (scriptParameter.DefaultValue == null) { return null; } return _executionVisitor.EvaluateAst(scriptParameter.DefaultValue); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { return(AstVisitAction.Continue); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { throw new NotImplementedException(); //VisitParameter(parameterAst); }
public override AstVisitAction VisitParameter(ParameterAst ast) { return this.Check(ast); }
public object VisitParameter(ParameterAst parameterAst) { return AutomationNull.Value; }
/// <summary/> public virtual object VisitParameter(ParameterAst parameterAst) { return(null); }
private static RuntimeDefinedParameter GetRuntimeDefinedParameter(ParameterAst parameterAst, ref bool customParameterSet, ref bool usesCmdletBinding) { List<Attribute> attributes = new List<Attribute>(); bool hasParameterAttribute = false; for (int index = 0; index < parameterAst.Attributes.Count; index++) { var attributeAst = parameterAst.Attributes[index]; var attribute = attributeAst.GetAttribute(); attributes.Add(attribute); var parameterAttribute = attribute as ParameterAttribute; if (parameterAttribute != null) { hasParameterAttribute = true; usesCmdletBinding = true; if (parameterAttribute.Position != int.MinValue || !parameterAttribute.ParameterSetName.Equals(ParameterAttribute.AllParameterSets, StringComparison.OrdinalIgnoreCase)) { customParameterSet = true; } } } attributes.Reverse(); if (!hasParameterAttribute) { attributes.Insert(0, new ParameterAttribute()); } var result = new RuntimeDefinedParameter(parameterAst.Name.VariablePath.UserPath, parameterAst.StaticType, new Collection<Attribute>(attributes.ToArray())); if (parameterAst.DefaultValue != null) { object constantValue; if (IsConstantValueVisitor.IsConstant(parameterAst.DefaultValue, out constantValue)) { result.Value = constantValue; } else { // Expression isn't constant, create a wrapper that holds the ast, and if necessary, // will cache a delegate to evaluate the default value. result.Value = new DefaultValueExpressionWrapper { Expression = parameterAst.DefaultValue }; } } else { object defaultValue; if (TryGetDefaultParameterValue(parameterAst.StaticType, out defaultValue) && defaultValue != null) { // Skip setting the value when defaultValue is null because if we do call the setter, // we'll try converting null to the parameter, which we might not want, e.g. if the parameter is [ref]. result.Value = defaultValue; } } return result; }
public object VisitParameter(ParameterAst parameterAst) { return false; }
public object VisitParameter(ParameterAst parameterAst) { Diagnostics.Assert(false, "Nothing to generate for a parameter"); return null; }
/// <summary/> public virtual AstVisitAction VisitParameter(ParameterAst parameterAst) { return(AstVisitAction.Continue); }
public override AstVisitAction VisitParameter(ParameterAst parameterAst) { return AstVisitAction.Continue; }
public object VisitParameter(ParameterAst parameterAst) { return(AutomationNull.Value); }
public override AstVisitAction VisitParameter(ParameterAst ast) { return CheckParent(ast); }