public void SetUp() { extent = Substitute.For<IScriptExtent>(); argument = new VariableExpressionAst(extent, "other", false); visitor = new FindTypeDefinitionVisitor(); }
public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue) : base(extent) { this.Name = name; this.Attributes = attributes.ToReadOnlyCollection(); this.DefaultValue = defaultValue; }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast) { if (IsTypeDefinitionAst) VarName = ast.VariablePath.UserPath; return AstVisitAction.Continue; }
public void LastAssignmentStatementAst_should_be_null_when_not_equals_operation() { var leftExpressionAst = new VariableExpressionAst(extent, varName, false); var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.MinusEquals); visitor.VisitAssignmentStatement(assignmentStatementAst); visitor.LastAssignmentStatementAst.Should().BeNull(); }
public void LastAssignmentStatementAst_should_be_ast() { var leftExpressionAst = new VariableExpressionAst(extent, varName , false); var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.Equals); visitor.VisitAssignmentStatement(assignmentStatementAst); visitor.LastAssignmentStatementAst.Should().BeSameAs(assignmentStatementAst); }
public void LastAssignmentStatementAst_should_be_null_after_visit_command() { var leftExpressionAst = new VariableExpressionAst(extent, varName, false); var assignmentStatementAst = GetAssignmentStatementAst(leftExpressionAst, TokenKind.Equals); visitor.VisitCommand(commandAst); visitor.VisitAssignmentStatement(assignmentStatementAst); visitor.LastAssignmentStatementAst.Should().BeNull(); }
private void AddVariable(int startIndex, int endIndex) { if (endIndex <= startIndex + 1) return; string variableName = GetText(startIndex + 1, endIndex); IScriptExtent variableExtent = GetScriptExtent(startIndex, endIndex); var variableAst = new VariableExpressionAst(variableExtent, variableName, false); _nestedExpressions.Add(variableAst); }
public ForEachStatementAst(IScriptExtent extent, string label, ForEachFlags flags, VariableExpressionAst variable, PipelineBaseAst expression, StatementBlockAst body) : base(extent, label, expression, body) { if ((expression == null) || (variable == null)) { throw PSTraceSource.NewArgumentNullException((expression == null) ? "expression" : "variablePath"); } this.Flags = flags; this.Variable = variable; base.SetParent(variable); }
/// <summary> /// Checks to see if this variable expression is the symbol we are looking for. /// </summary> /// <param name="variableExpressionAst">A VariableExpressionAst object in the script's AST</param> /// <returns>A descion to stop searching if the right symbol was found, /// or a decision to continue if it wasn't found</returns> public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { if (!IsAssignedAtScriptScope(variableExpressionAst)) { return AstVisitAction.Continue; } this.SymbolReferences.Add( new SymbolReference( SymbolType.Variable, variableExpressionAst.Extent)); return AstVisitAction.Continue; }
/// <summary> /// Decides if the current variable expression is the right defition for /// the symbol being searched for. The defintion of the symbol will be a of type /// SymbolType.Variable and have the same name as the symbol /// </summary> /// <param name="variableExpressionAst">A FunctionDefinitionAst in the script's AST</param> /// <returns>A descion to stop searching if the right VariableExpressionAst was found, /// or a decision to continue if it wasn't found</returns> public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { if(symbolRef.SymbolType.Equals(SymbolType.Variable) && variableExpressionAst.Extent.Text.Equals(symbolRef.SymbolName, StringComparison.InvariantCultureIgnoreCase)) { this.FoundDeclartion = new SymbolReference( SymbolType.Variable, variableExpressionAst.Extent); return AstVisitAction.StopVisit; } return AstVisitAction.Continue; }
private bool IsAssignedAtScriptScope(VariableExpressionAst variableExpressionAst) { Ast parent = variableExpressionAst.Parent; if (!(parent is AssignmentStatementAst)) { return false; } parent = parent.Parent; if (parent == null || parent.Parent == null || parent.Parent.Parent == null) { return true; } return false; }
private static object GetAutomaticVariableValue(int tupleIndex, ExecutionContext executionContext, VariableExpressionAst varAst) { if (executionContext._debuggingMode > 0) { executionContext.Debugger.CheckVariableRead(SpecialVariables.AutomaticVariables[tupleIndex]); } object automaticVariableValue = executionContext.EngineSessionState.GetAutomaticVariableValue((AutomaticVariable) tupleIndex); if (automaticVariableValue != AutomationNull.Value) { return automaticVariableValue; } if (ThrowStrictModeUndefinedVariable(executionContext, varAst)) { throw InterpreterError.NewInterpreterException(SpecialVariables.AutomaticVariables[tupleIndex], typeof(RuntimeException), varAst.Extent, "VariableIsUndefined", ParserStrings.VariableIsUndefined, new object[] { SpecialVariables.AutomaticVariables[tupleIndex] }); } return null; }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { bool flag = false; if (variableExpressionAst.VariablePath.IsAnyLocal()) { string unqualifiedPath = variableExpressionAst.VariablePath.UnqualifiedPath; if (this._validVariables.Contains(unqualifiedPath) || unqualifiedPath.Equals("args", StringComparison.OrdinalIgnoreCase)) { flag = true; this.UsesParameter = true; } else { flag = !variableExpressionAst.Splatted && variableExpressionAst.IsConstantVariable(); } } if (!flag) { ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithUndeclaredVariables", null, AutomationExceptions.CantConvertWithUndeclaredVariables, new object[] { variableExpressionAst.VariablePath }), variableExpressionAst); } return AstVisitAction.Continue; }
public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue) : base(extent) { if (name == null) { throw PSTraceSource.NewArgumentNullException("name"); } if ((attributes != null) && attributes.Any<AttributeBaseAst>()) { this.Attributes = new ReadOnlyCollection<AttributeBaseAst>(attributes.ToArray<AttributeBaseAst>()); base.SetParents(attributes); } else { this.Attributes = EmptyAttributeList; } this.Name = name; base.SetParent(name); if (defaultValue != null) { this.DefaultValue = defaultValue; base.SetParent(defaultValue); } }
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return(variableExpressionAst.IsConstantVariable()); }
private void GetSplattedVariable(VariableExpressionAst variableAst) { if (_context == null) { throw new PSInvalidOperationException(AutomationExceptions.CantConvertScriptBlockWithNoContext); } // Process the contents of a splatted variable into the arguments for this // command. If the variable contains a hashtable, distribute the key/value pairs // If it's an enumerable, then distribute the values as $args and finally // if it's a scalar, then the effect is equivalent to $var object splattedValue = _context.GetVariableValue(variableAst.VariablePath); foreach (var splattedParameter in PipelineOps.Splat(splattedValue, variableAst.Extent)) { CommandParameter publicParameter = CommandParameter.FromCommandParameterInternal(splattedParameter); _powershell.AddParameter(publicParameter.Name, publicParameter.Value); } }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { bool usesParameterReference = this.UsesParameter; bool ok = variableExpressionAst.IsSafeVariableReference(_validVariables, ref usesParameterReference); if (usesParameterReference != this.UsesParameter) { this.UsesParameter = usesParameterReference; } if (!ok) { ThrowError(new ScriptBlockToPowerShellNotSupportedException( "CantConvertWithUndeclaredVariables", null, AutomationExceptions.CantConvertWithUndeclaredVariables, variableExpressionAst.VariablePath), variableExpressionAst); } return AstVisitAction.Continue; }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { _pipelineCommandRuntime.WriteObject(new SettableVariableExpression(variableExpressionAst, this).GetValue()); return AstVisitAction.SkipChildren; }
/// <summary/> public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return _decorated.VisitVariableExpression(variableExpressionAst); }
/// <summary/> public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) => DefaultVisit(variableExpressionAst);
public ForEachStatementAst(IScriptExtent extent, string label, ForEachFlags flags, VariableExpressionAst variable, PipelineBaseAst expression, StatementBlockAst body) : base(extent, label, expression, body) { this.Flags = flags; this.Variable = variable; }
/// <summary> /// Checks to see if this variable expression is the symbol we are looking for. /// </summary> /// <param name="variableExpressionAst">A VariableExpressionAst object in the script's AST</param> /// <returns>A descion to stop searching if the right symbol was found, /// or a decision to continue if it wasn't found</returns> public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return this.findSymbolsVisitor.VisitVariableExpression(variableExpressionAst); }
public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return AstVisitAction.Continue; }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { var variable = GetVariable(variableExpressionAst); this._pipelineCommandRuntime.WriteObject(variable.Value, true); return AstVisitAction.SkipChildren; }
public override AstVisitAction VisitVariableExpression(VariableExpressionAst ast) { return(Check(ast)); }
/// <summary> /// Checks to see if this variable expression is the symbol we are looking for. /// </summary> /// <param name="variableExpressionAst">A VariableExpressionAst object in the script's AST</param> /// <returns>A descion to stop searching if the right symbol was found, /// or a decision to continue if it wasn't found</returns> public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { if (this.IsPositionInExtent(variableExpressionAst.Extent)) { this.FoundSymbolReference = new SymbolReference( SymbolType.Variable, variableExpressionAst.Extent); return AstVisitAction.StopVisit; } return AstVisitAction.Continue; }
/// <summary> /// Visit variable expression /// </summary> /// <param name="variableExpressionAst"></param> /// <returns></returns> public object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return null; }
/// <summary/> public virtual object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { 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); }
public System.Object VisitVariableExpression(System.Management.Automation.Language.VariableExpressionAst variableExpressionAst) { IScriptExtent mappedExtent = MapExtent(variableExpressionAst.Extent); return(new VariableExpressionAst(mappedExtent, variableExpressionAst.VariablePath, variableExpressionAst.Splatted)); }
public virtual AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return(AstVisitAction.Continue); }
private PSVariable GetVariable(VariableExpressionAst variableExpressionAst) { var variable = this._context.SessionState.PSVariable.Get(variableExpressionAst.VariablePath.UserPath); return variable; }
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { VariablePath variablePath = variableExpressionAst.VariablePath; if (variablePath.IsAnyLocal()) { VariableAnalysisDetails details = this._variables[GetUnaliasedVariableName(variablePath)]; if (details.LocalTupleIndex != -1) { variableExpressionAst.TupleIndex = details.PreferenceVariable ? -2 : details.LocalTupleIndex; variableExpressionAst.Automatic = details.Automatic; } else { this._currentBlock.AddAst(variableExpressionAst); } details.AssociatedAsts.Add(variableExpressionAst); } else { variableExpressionAst.TupleIndex = -2; } return null; }
internal SettableVariableExpression(VariableExpressionAst expressionAst, ExecutionVisitor currentExecution) : base(currentExecution) { _expressionAst = expressionAst; }
/// <summary> /// Constructor that takes in a VariableExpressionAst /// </summary> /// <param name="varExpression"></param> public VariableTarget(VariableExpressionAst varExpression) { if (varExpression != null) { Name = AssignmentTarget.GetUnaliasedVariableName(varExpression.VariablePath); VarAst = varExpression; RealName = Name; } }
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst) { return variableExpressionAst.IsConstantVariable(); }
private void SetVariableName() { ExpressionAst lhs = (_targetAst is ConvertExpressionAst) ? (_targetAst as ConvertExpressionAst).Child : _targetAst; _leftHandSideVariable = lhs as VariableExpressionAst; if (_leftHandSideVariable == null) { return; } Name = GetUnaliasedVariableName(_leftHandSideVariable.VariablePath); RealName = Name; }
/// <summary> /// Visit VariableExpression /// </summary> /// <param name="variableExpressionAst"></param> /// <returns></returns> public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst) { if (variableExpressionAst == null) { return AstVisitAction.Continue; } NoteVariable(AssignmentTarget.GetUnaliasedVariableName(variableExpressionAst.VariablePath), null); return AstVisitAction.Continue; }