public CaseExpression(Expression value, WhenClause/*!*/[] whenClauses, Statements elseStatements, SourceSpan location)
     : base(location)
 {
     _value = value;
     _whenClauses = whenClauses ?? WhenClause.EmptyArray;
     _elseStatements = elseStatements;
 }

 public ForLoopExpression(CompoundLeftValue/*!*/ variables, Expression/*!*/ list, Statements body, SourceSpan location)
     : base(location) {
     Assert.NotNull(variables, list);
     
     _block = new BlockDefinition(null, variables, body, location);
     _list = list;
 }

        public Finalizer(LexicalScope/*!*/ definedScope, Statements statements, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope);

            _definedScope = definedScope;
            _statements = statements;
        }

        public ForLoopExpression(LexicalScope/*!*/ definedScope, Parameters/*!*/ variables, Expression/*!*/ list, Statements body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, variables, list);

            _block = new BlockDefinition(definedScope, variables, body, location);
            _list = list;
        }

 public RescueClause(CompoundRightValue type, LeftValue target, Statements statements, SourceSpan location)
     : base(location) {
     _types = type.RightValues;
     _splatType = type.SplattedValue;
     _target = target;
     _statements = statements;
 }

        internal BlockExpression(Statements/*!*/ statements, SourceSpan location)
            : base(location) {
            Assert.NotNull(statements);
            Debug.Assert(statements.Count > 1);

            _statements = statements;
        }

 /// <summary>
 /// Creates a new for loop statement. Usage:
 /// for 'identifier' in 'firstExpression' .. 'secondExpression' do 'statements' end for;
 /// </summary>
 /// <param name="identifier">Iterator's identifier</param>
 /// <param name="firstExpression">Starting value</param>
 /// <param name="secondExpression">Ending value</param>
 /// <param name="statements">Statements to execute</param>
 public StatementFor(string identifier, Expression firstExpression, Expression secondExpression, Statements statements)
 {
     Identifier = identifier;
     FirstExpression = firstExpression;
     SecondExpression = secondExpression;
     Statements = statements;
 }

 public ElseIfClause(Expression condition, Statements/*!*/ statements, SourceSpan location)
     : base(location)
 {
     Assert.NotNull(statements);
     _statements = statements;
     _condition = condition;
 }

        public CaseExpression(Expression value, List<WhenClause>/*!*/ whenClauses, Statements elseStatements, SourceSpan location)
            : base(location) {
            ContractUtils.RequiresNotNull(whenClauses, "whenClauses");

            _value = value;
            _whenClauses = whenClauses;
            _elseStatements = elseStatements;
        }

        public BlockDefinition(LexicalScope/*!*/ definedScope, CompoundLeftValue/*!*/ parameters, Statements/*!*/ body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, parameters, body);

            _definedScope = definedScope;
            _body = body;
            _parameters = parameters;
        }

        private readonly Expression[] _types; // might be empty, might include SplattedArgument expressions

        #endregion Fields

        #region Constructors

        public RescueClause(Expression/*!*/[]/*!*/ types, LeftValue target, Statements statements, SourceSpan location)
            : base(location)
        {
            Assert.NotNullItems(types);
            _types = types;
            _target = target;
            _statements = statements;
        }

        public BlockDefinition(LexicalScope/*!*/ definedScope, Parameters parameters, Statements/*!*/ body, SourceSpan location)
            : base(location) {
            Assert.NotNull(definedScope, body);

            _definedScope = definedScope;
            _body = body;
            _parameters = parameters ?? Parameters.Empty; 
        }

        public UnlessExpression(Expression/*!*/ condition, Statements/*!*/ statements, ElseIfClause elseClause, SourceSpan location)
            : base(location) {
            ContractUtils.RequiresNotNull(condition, "condition");
            ContractUtils.RequiresNotNull(statements, "statements");
            ContractUtils.Requires(elseClause == null || elseClause.Condition == null, "elseClause", "No condition allowed.");

            _statements = statements;
            _condition = condition;
            _elseClause = elseClause;
        }

        public WhileLoopExpression(Expression/*!*/ condition, bool isWhileLoop, bool isPostTest, Statements/*!*/ statements, SourceSpan location)
            : base(location) {

            ContractUtils.RequiresNotNull(condition, "condition");
            ContractUtils.RequiresNotNull(statements, "statements");

            _condition = condition;
            _isWhileLoop = isWhileLoop;
            _isPostTest = isPostTest;
            _statements = statements;
        }

        public Body(Statements/*!*/ statements, List<RescueClause> rescueClauses, Statements elseStatements,
            Statements ensureStatements, SourceSpan location)
            : base(location) {

            Assert.NotNull(statements);

            _statements = statements;
            _rescueClauses = rescueClauses;
            _elseStatements = elseStatements;
            _ensureStatements = ensureStatements;
        }

        public static void CopyFile(FileInfo source, FileInfo destination,
            Statements.FileCopyOptions options, CopyFileHandler callback, object state)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (destination == null) throw new ArgumentNullException("destination");

            new FileIOPermission(FileIOPermissionAccess.Read, source.FullName).Demand();
            new FileIOPermission(FileIOPermissionAccess.Write, destination.FullName).Demand();

            CopyProgressRoutine cpr = (callback == null) ? null : new CopyProgressRoutine(
                new CopyProgressData(source, destination, callback, state).CallbackHandler);

            bool cancel = false;
            if (!NativeMethod.CopyFileEx(source.FullName, destination.FullName, cpr, IntPtr.Zero, ref cancel, (int)options))
                throw new IOException(new Win32Exception().Message);
        }

        public IfExpression(Expression/*!*/ condition, Statements/*!*/ body, List<ElseIfClause>/*!*/ elseIfClauses, SourceSpan location)
            : base(location) {
            ContractUtils.RequiresNotNull(body, "body");
            ContractUtils.RequiresNotNull(condition, "condition");
            ContractUtils.RequiresNotNull(elseIfClauses, "elseIfClauses");

            // all but the last clause should have non-null conditions:
            for (int i = 0; i < elseIfClauses.Count - 1; i++) {
                if (elseIfClauses[i].Condition == null) {
                    throw ExceptionUtils.MakeArgumentItemNullException(i, "elseIfClauses");
                }
            }

            _condition = condition;
            _body = body;
            _elseIfClauses = elseIfClauses;
        }

 public bool Resume(Bookmark bookmark, FileInfo source, FileInfo destination, Statements.FileCopyOptions options, int stepIncrement)
 {
     var context = new CopyFileContext(stepIncrement)
     {
         Instance = this,
         Bookmark = bookmark,
         Action = CopyFileAction.Continue
     };
     if (contexts.TryAdd(bookmark.Name, context))
     {
         var action = new Action(() => ExecuteCopyFile(context, source, destination, options));
         action.BeginInvoke((a) =>
         {
             try { action.EndInvoke(a); }
             catch (Exception ex) { ((CopyFileContext)a.AsyncState).Exception = ex; }
             finally { ((CopyFileContext)a.AsyncState).NotifyCompletion(); }
         }, context);
         return true;
     }
     return false;
 }

		public virtual void Visit(Statements.TryStatement.FinallyStatement s)
		{
			VisitChildren(s);
		}