public TryStatementAst(IScriptExtent extent, StatementBlockAst body, IEnumerable<CatchClauseAst> catchClauses, StatementBlockAst @finally)
     : base(extent)
 {
     this.Body = body;
     this.CatchClauses = catchClauses.ToReadOnlyCollection();
     this.Finally = @finally;
 }

        /// <summary>
        /// Constructor for InvocationInfo object
        /// </summary>
        /// 
        /// <param name="commandInfo">
        /// The command information the invocation info represents.
        /// </param>
        /// 
        /// <param name="scriptPosition">
        /// The position representing the invocation, or the position representing the error.
        /// </param>
        /// 
        /// <param name="context">
        /// The context in which the InvocationInfo is being created.
        /// </param>
        /// 
        internal InvocationInfo(CommandInfo commandInfo, IScriptExtent scriptPosition, ExecutionContext context)
        {
            MyCommand = commandInfo;
            CommandOrigin = CommandOrigin.Internal;
            _scriptPosition = scriptPosition;

            ExecutionContext contextToUse = null;
            if ((commandInfo != null) && (commandInfo.Context != null))
            {
                contextToUse = commandInfo.Context;
            }
            else if (context != null)
            {
                contextToUse = context;
            }

            // Populate the history ID of this command
            if (contextToUse != null)
            {
                Runspaces.LocalRunspace localRunspace = contextToUse.CurrentRunspace as Runspaces.LocalRunspace;
                if (localRunspace != null && localRunspace.History != null)
                {
                    HistoryId = localRunspace.History.GetNextHistoryId();
                }
            }
        }

 public DataStatementAst(IScriptExtent extent, string variableName, IEnumerable<ExpressionAst> commandsAllowed, StatementBlockAst body) : base(extent)
 {
     this._tupleIndex = -1;
     if (body == null)
     {
         throw PSTraceSource.NewArgumentNullException("body");
     }
     if (string.IsNullOrWhiteSpace(variableName))
     {
         variableName = null;
     }
     this.Variable = variableName;
     if ((commandsAllowed != null) && commandsAllowed.Any<ExpressionAst>())
     {
         this.CommandsAllowed = new ReadOnlyCollection<ExpressionAst>(commandsAllowed.ToArray<ExpressionAst>());
         base.SetParents((IEnumerable<Ast>) this.CommandsAllowed);
         this.HasNonConstantAllowedCommand = (from ast in this.CommandsAllowed
             where !(ast is StringConstantExpressionAst)
             select ast).Any<ExpressionAst>();
     }
     else
     {
         this.CommandsAllowed = new ReadOnlyCollection<ExpressionAst>(EmptyCommandsAllowed);
     }
     this.Body = body;
     base.SetParent(body);
 }

 public ScriptBlockAst(IScriptExtent extent, ParamBlockAst paramBlock, NamedBlockAst beginBlock, NamedBlockAst processBlock, NamedBlockAst endBlock, NamedBlockAst dynamicParamBlock) : base(extent)
 {
     if (paramBlock != null)
     {
         this.ParamBlock = paramBlock;
         base.SetParent(paramBlock);
     }
     if (beginBlock != null)
     {
         this.BeginBlock = beginBlock;
         base.SetParent(beginBlock);
     }
     if (processBlock != null)
     {
         this.ProcessBlock = processBlock;
         base.SetParent(processBlock);
     }
     if (endBlock != null)
     {
         this.EndBlock = endBlock;
         base.SetParent(endBlock);
     }
     if (dynamicParamBlock != null)
     {
         this.DynamicParamBlock = dynamicParamBlock;
         base.SetParent(dynamicParamBlock);
     }
 }

 public CommandParameterAst(IScriptExtent extent, string parameterName, ExpressionAst argument, IScriptExtent errorPosition)
     : base(extent)
 {
     this.ParameterName = parameterName;
     this.Argument = argument;
     this.ErrorPosition = errorPosition;
 }

 public ExpandableStringExpressionAst(IScriptExtent extent, string value, System.Management.Automation.Language.StringConstantType type) : base(extent)
 {
     if (value == null)
     {
         throw PSTraceSource.NewArgumentNullException("value");
     }
     if (((type != System.Management.Automation.Language.StringConstantType.DoubleQuoted) && (type != System.Management.Automation.Language.StringConstantType.DoubleQuotedHereString)) && (type != System.Management.Automation.Language.StringConstantType.BareWord))
     {
         throw PSTraceSource.NewArgumentException("type");
     }
     ExpressionAst ast = Parser.ScanString(value);
     ExpandableStringExpressionAst ast2 = ast as ExpandableStringExpressionAst;
     if (ast2 != null)
     {
         this.FormatExpression = ast2.FormatExpression;
         this.NestedExpressions = ast2.NestedExpressions;
     }
     else
     {
         this.FormatExpression = "{0}";
         this.NestedExpressions = new ReadOnlyCollection<ExpressionAst>(new ExpressionAst[] { ast });
     }
     this.Value = value;
     this.StringConstantType = type;
 }

 internal ErrorStatementAst(IScriptExtent extent, Token kind, IEnumerable<KeyValuePair<string, Tuple<Token, Ast>>> flags, IEnumerable<Ast> conditions, IEnumerable<Ast> bodies) : base(extent)
 {
     if (kind == null)
     {
         throw PSTraceSource.NewArgumentNullException("kind");
     }
     this.Kind = kind;
     if ((flags != null) && flags.Any<KeyValuePair<string, Tuple<Token, Ast>>>())
     {
         this.Flags = new Dictionary<string, Tuple<Token, Ast>>(StringComparer.OrdinalIgnoreCase);
         foreach (KeyValuePair<string, Tuple<Token, Ast>> pair in flags)
         {
             if (!this.Flags.ContainsKey(pair.Key))
             {
                 this.Flags.Add(pair.Key, pair.Value);
                 if (pair.Value.Item2 != null)
                 {
                     base.SetParent(pair.Value.Item2);
                 }
             }
         }
     }
     if ((conditions != null) && conditions.Any<Ast>())
     {
         this.Conditions = new ReadOnlyCollection<Ast>(conditions.ToArray<Ast>());
         base.SetParents(conditions);
     }
     if ((bodies != null) && bodies.Any<Ast>())
     {
         this.Bodies = new ReadOnlyCollection<Ast>(bodies.ToArray<Ast>());
         base.SetParents(bodies);
     }
 }

 public SwitchStatementAst(IScriptExtent extent, string label, PipelineBaseAst condition, SwitchFlags flags, IEnumerable<Tuple<ExpressionAst, StatementBlockAst>> clauses, StatementBlockAst @default)
     : base(extent, label, condition)
 {
     this.Flags = flags;
     this.Clauses = clauses.ToReadOnlyCollection();
     this.Default = @default;
 }

 public FunctionDefinitionAst(IScriptExtent extent, bool isFilter, bool isWorkflow, string name, IEnumerable<ParameterAst> parameters, ScriptBlockAst body) : base(extent)
 {
     if (string.IsNullOrEmpty(name))
     {
         throw PSTraceSource.NewArgumentNullException("name");
     }
     if (body == null)
     {
         throw PSTraceSource.NewArgumentNullException("body");
     }
     if (isFilter && isWorkflow)
     {
         throw PSTraceSource.NewArgumentException("isFilter");
     }
     this.IsFilter = isFilter;
     this.IsWorkflow = isWorkflow;
     this.Name = name;
     if ((parameters != null) && parameters.Any<ParameterAst>())
     {
         this.Parameters = new ReadOnlyCollection<ParameterAst>(parameters.ToArray<ParameterAst>());
         base.SetParents((IEnumerable<Ast>) this.Parameters);
     }
     this.Body = body;
     base.SetParent(body);
 }

 internal ParseError(IScriptExtent extent, string errorId, string message, bool incompleteInput)
 {
     this._extent = extent;
     this._errorId = errorId;
     this._message = message;
     this._incompleteInput = incompleteInput;
 }

 public ParameterAst(IScriptExtent extent, VariableExpressionAst name, IEnumerable<AttributeBaseAst> attributes, ExpressionAst defaultValue)
     : base(extent)
 {
     this.Name = name;
     this.Attributes = attributes.ToReadOnlyCollection();
     this.DefaultValue = defaultValue;
 }

        public void SetUp()
        {
            extent = Substitute.For<IScriptExtent>();
            argument = new VariableExpressionAst(extent, "other", false);

            visitor = new FindTypeDefinitionVisitor();
        }

 public UpdatePositionExpr(IScriptExtent extent, int sequencePoint, SymbolDocumentInfo debugSymbolDocument, bool checkBreakpoints)
 {
     this._extent = extent;
     this._checkBreakpoints = checkBreakpoints;
     this._debugSymbolDocument = debugSymbolDocument;
     this._sequencePoint = sequencePoint;
 }

 public DataStatementAst(IScriptExtent extent, string variableName, IEnumerable<ExpressionAst> commandsAllowed, StatementBlockAst body)
     : base(extent)
 {
     this.Variable = variableName;
     this.CommandsAllowed = commandsAllowed.ToReadOnlyCollection();
     this.Body = body;
 }

 public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static)
     : base(extent)
 {
     this.Expression = expression;
     this.Member = member;
     this.Static = @static;
 }

 public TryStatementAst(IScriptExtent extent, StatementBlockAst body, IEnumerable<CatchClauseAst> catchClauses, StatementBlockAst @finally) : base(extent)
 {
     if (body == null)
     {
         throw PSTraceSource.NewArgumentNullException("body");
     }
     if (((catchClauses == null) || !catchClauses.Any<CatchClauseAst>()) && (@finally == null))
     {
         throw PSTraceSource.NewArgumentException("catchClauses");
     }
     this.Body = body;
     base.SetParent(body);
     if ((catchClauses != null) && catchClauses.Any<CatchClauseAst>())
     {
         this.CatchClauses = new ReadOnlyCollection<CatchClauseAst>(catchClauses.ToArray<CatchClauseAst>());
         base.SetParents((IEnumerable<Ast>) this.CatchClauses);
     }
     else
     {
         this.CatchClauses = EmptyCatchClauses;
     }
     if (@finally != null)
     {
         this.Finally = @finally;
         base.SetParent(@finally);
     }
 }

 public ScriptBlockAst(IScriptExtent extent, ParamBlockAst paramBlock, StatementBlockAst statements, bool isFilter)
     : base(extent)
 {
     this.ParamBlock = paramBlock;
     this.EndBlock = new NamedBlockAst(extent, TokenKind.End, statements, true);
     if (isFilter) throw new NotImplementedException(this.ToString());
 }

 public NamedAttributeArgumentAst(IScriptExtent extent, string argumentName, ExpressionAst argument, bool expressionOmitted)
     : base(extent)
 {
     this.Argument = argument;
     this.ArgumentName = argumentName;
     this.ExpressionOmitted = expressionOmitted;
 }

 public AssignmentStatementAst(IScriptExtent extent, ExpressionAst left, TokenKind @operator, StatementAst right, IScriptExtent errorPosition) : base(extent)
 {
     if (((left == null) || (right == null)) || (errorPosition == null))
     {
         throw PSTraceSource.NewArgumentNullException((left == null) ? "left" : ((right == null) ? "right" : "errorPosition"));
     }
     if ((@operator.GetTraits() & TokenFlags.AssignmentOperator) == TokenFlags.None)
     {
         throw PSTraceSource.NewArgumentException("operator");
     }
     PipelineAst ast = right as PipelineAst;
     if ((ast != null) && (ast.PipelineElements.Count == 1))
     {
         CommandExpressionAst ast2 = ast.PipelineElements[0] as CommandExpressionAst;
         if (ast2 != null)
         {
             right = ast2;
             right.ClearParent();
         }
     }
     this.Operator = @operator;
     this.Left = left;
     base.SetParent(left);
     this.Right = right;
     base.SetParent(right);
     this.ErrorPosition = errorPosition;
 }

 public DoUntilStatementAst(IScriptExtent extent, string label, PipelineBaseAst condition, StatementBlockAst body) : base(extent, label, condition, body)
 {
     if (condition == null)
     {
         throw PSTraceSource.NewArgumentNullException("condition");
     }
 }