internal ForCSharpStatement(ReadOnlyCollection<ParameterExpression> variables, ReadOnlyCollection<Expression> initializers, Expression test, ReadOnlyCollection<Expression> iterators, Expression body, LabelTarget breakLabel, LabelTarget continueLabel)
     : base(test, body, breakLabel, continueLabel)
 {
     Variables = variables;
     Initializers = initializers;
     Iterators = iterators;
 }

        public Expression Update(LabelTarget labelTarget, Type type) {
            if (LabelTarget.Equals(labelTarget) && Type.Equals(type)) {
                return this;
            }

            return AstExpression.Label(_labelStatement, ParentScope, Visitor);
        }

        public Expression Update(LabelTarget labelTarget, Type type) {
            if (LabelTarget.Equals(labelTarget) && Type.Equals(type)) {
                return this;
            }

            return AstExpression.Goto(_gotoStatement, this as IScope, Visitor);
        }

 public override void BeforeVisit(Function node)
 {
     base.BeforeVisit(node);
     //_currentOutputExp = Expression.Parameter(typeof (TextWriter), CurrentOutputIdentifier);
     //Create return target
     _returnLabelTarget = Expression.Label(typeof(object), "lambdaReturn");
 }

        public override Expression Compile(ParameterExpression stateParameterExpression, LabelTarget returnTarget, LogicExpression valueExpression)
        {
            var value = this.Target.Compile(stateParameterExpression, returnTarget);
            var convertedValue = Expression.Convert(value, typeof(LogicStructureInstance));

            var valueVariable = Expression.Variable(typeof(LogicStructureInstance), "value");
            var field = Expression.Variable(typeof(LogicField), "field");

            Expression<Func<LogicStructureInstance, string, LogicField>> lookupField =
                (x, z) => x.Fields.Keys.First(y => y.Name == z);

            var assignValue = Expression.Assign(valueVariable, convertedValue);
            var assignFieldName = Expression.Assign(
                field,
                Expression.Invoke(lookupField, valueVariable, Expression.Constant(this.Field)));
            var assignField =
                Expression.Assign(
                    Expression.Property(Expression.Property(valueVariable, "Fields"), "Item", field),
                    Expression.Convert(valueExpression.Compile(stateParameterExpression, returnTarget), typeof(object)));
            var assignFieldSet =
                Expression.Assign(
                    Expression.Property(Expression.Property(valueVariable, "FieldsSet"), "Item", field),
                    Expression.Constant(true));

            return Expression.Block(
                new[] { valueVariable, field },
                assignValue,
                assignFieldName,
                assignField,
                assignFieldSet);
        }

 internal GotoExpression(GotoExpressionKind kind, LabelTarget target, Expression value, Type type)
 {
     _kind = kind;
     _value = value;
     _target = target;
     _type = type;
 }

        public sealed override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel) {
            if (args.Length == 0) {
                throw new InvalidOperationException();
            }

            MetaObject[] mos;
            if (args.Length != 1) {
                mos = new MetaObject[args.Length - 1];
                for (int i = 1; i < args.Length; i++) {
                    mos[i - 1] = MetaObject.ObjectToMetaObject(args[i], parameters[i]);
                }
            } else {
                mos = MetaObject.EmptyMetaObjects;
            }

            MetaObject binding = Bind(
                MetaObject.ObjectToMetaObject(args[0], parameters[0]),
                mos
            );

            if (binding == null) {
                throw Error.BindingCannotBeNull();
            }

            return GetMetaObjectRule(binding, returnLabel);
        }

 public static LoopExpression Loop(Expression body, LabelTarget @break, LabelTarget @continue) {
     RequiresCanRead(body, "body");
     // TODO: lift the restriction on break, and allow loops to have non-void type
     ContractUtils.Requires(@break == null || @break.Type == typeof(void), "break", Strings.LabelTypeMustBeVoid);
     ContractUtils.Requires(@continue == null || @continue.Type == typeof(void), "continue", Strings.LabelTypeMustBeVoid);
     return new LoopExpression(body, @break, @continue);
 }

        public ForEachExpression Update(ParameterExpression variable, Expression enumerable, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
        {
            if (this.variable == variable && this.enumerable == enumerable && this.body == body && break_target == breakTarget && continue_target == continueTarget)
                return this;

            return CustomExpression.ForEach(variable, enumerable, body, continueTarget, breakTarget);
        }

        public Expression Update(LabelTarget target, Type type, Expression value) {
            if (Target.Equals(target) && Type.Equals(type) && Value.Equals(value)) {
                return this;
            }

            return AstExpression.Break(_breakStatement, ParentScope, Visitor);
        }

        public AplusScope(AplusScope parent,
            string name,
            Aplus runtime = null,
            DLR.ParameterExpression runtimeParam = null,
            DLR.ParameterExpression moduleParam = null,
            DLR.LabelTarget returnTarget = null,
            bool isEval = false,
            bool isMethod = false,
            bool isAssignment = false)
        {
            this.parent = parent;
            this.name = name;
            this.runtime = runtime;
            this.runtimeParam = runtimeParam;
            this.moduleParam = moduleParam;

            this.returnTarget = returnTarget;

            this.variables = new Dictionary<string, DLR.ParameterExpression>();

            this.callbackInfo = new CallbackInfoStorage();

            this.iseval = isEval;

            this.ismethod = isMethod;
            this.isAssignment = isAssignment;

            InheritProperties(parent);
        }

        public Expression Update(LabelTarget label, Type type) {
            if (LabelTarget.Equals(label) && Type.Equals(type)) {
                return this;
            }

            return AstExpression.Continue(_continueStatement, this as IScope, Visitor);
        }

        public Expression Update(GotoExpressionKind kind, LabelTarget target, Expression value) {
            if (Target.Equals(target) && ReferenceEquals(Value, value) && Kind == kind) {
                return this;
            }

            return AstExpression.Return(_returnStatement, ParentScope, Visitor);
        }

        public Expression Update(LabelTarget target, Expression defaultValue) {
            if (Target.Equals(target) && DefaultValue == defaultValue) {
                return this;
            }

            return AstExpression.Label(_caseLabel, ParentScope, Visitor);
        }

        public static SwitchExpression Switch(Expression value, LabelTarget label, IEnumerable<SwitchCase> cases) {
            RequiresCanRead(value, "value");
            ContractUtils.Requires(value.Type == typeof(int), "value", Strings.ValueMustBeInt);
            ContractUtils.RequiresNotNull(cases, "cases");
            var caseList = cases.ToReadOnly();
            ContractUtils.RequiresNotEmpty(caseList, "cases");
            ContractUtils.RequiresNotNullItems(caseList, "cases");
            // TODO: does it make sense for switch to have non-void type?
            ContractUtils.Requires(label == null || label.Type == typeof(void), "label", Strings.LabelTypeMustBeVoid);

            bool @default = false;
            int max = Int32.MinValue;
            int min = Int32.MaxValue;
            foreach (SwitchCase sc in caseList) {
                if (sc.IsDefault) {
                    ContractUtils.Requires(@default == false, "cases", Strings.OnlyDefaultIsAllowed);
                    @default = true;
                } else {
                    int val = sc.Value;
                    if (val > max) max = val;
                    if (val < min) min = val;
                }
            }

            ContractUtils.Requires(UniqueCaseValues(caseList, min, max), "cases", Strings.CaseValuesMustBeUnique);

            return new SwitchExpression(value, label, caseList);
        }

 public override Expression Compile(ParameterExpression stateParameterExpression, LabelTarget returnTarget)
 {
     return Expression.Property(
         Expression.Property(stateParameterExpression, "Variables"),
         "Item",
         Expression.Constant(this.Identifier));
 }

        public Expression Update(LabelTarget target, Type type, Expression value) {
            if (Target.Equals(target) && Type.Equals(type) && Value.Equals(value)) {
                return this;
            }

            return AstExpression.Init(_variableInitializer, ParentScope, Visitor);
        }

 public LoopExpression Update (LabelTarget breakLabel, LabelTarget continueLabel, Expression body)
 {
   Contract.Requires(body != null);
   Contract.Requires(continueLabel == null || continueLabel.Type == typeof(void), "Continue label type must be void");
   Contract.Ensures(Contract.Result<LoopExpression>() != null);
   return default(LoopExpression);
 }

 public GotoExpression Update (LabelTarget target, Expression value)
 {
   Contract.Requires(target != null);
   Contract.Requires(value != null || target.Type == typeof(void), "Label type must be void when no value is provided");
   Contract.Ensures(Contract.Result<GotoExpression>() != null);
   return default(GotoExpression);
 }

        // Just splat the args and dispatch through a nested site
        public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel) {
            Debug.Assert(args.Length == 2);

            int count = ((object[])args[1]).Length;
            ParameterExpression array = parameters[1];

            var nestedArgs = new ReadOnlyCollectionBuilder<Expression>(count + 1);
            var delegateArgs = new Type[count + 3]; // args + target + returnType + CallSite
            nestedArgs.Add(parameters[0]);
            delegateArgs[0] = typeof(CallSite);
            delegateArgs[1] = typeof(object);
            for (int i = 0; i < count; i++) {
                nestedArgs.Add(Expression.ArrayAccess(array, Expression.Constant(i)));
                delegateArgs[i + 2] = typeof(object).MakeByRefType();
            }
            delegateArgs[delegateArgs.Length - 1] = typeof(object);

            return Expression.IfThen(
                Expression.Equal(Expression.ArrayLength(array), Expression.Constant(count)),
                Expression.Return(
                    returnLabel,
                    Expression.MakeDynamic(
                        Expression.GetDelegateType(delegateArgs),
                        new ComInvokeAction(new CallInfo(count)),
                        nestedArgs
                    )
                )
            );
        }