internal Compare(BinaryExpression expr, cmpop op)
     : this() {
     _left = Convert(expr.Left);
     _ops = PythonOps.MakeListNoCopy(op);
     _comparators = PythonOps.MakeListNoCopy(Convert(expr.Right));
 }

 internal BoolOp(AndExpression and)
     : this() {
     _values = PythonOps.MakeListNoCopy(Convert(and.Left), Convert(and.Right));
     _op = And.Instance;
 }

            internal Call(CallExpression call)
                : this() {
                _args = PythonOps.MakeEmptyList(call.Args.Count);
                _keywords = new PythonList();
                _func = Convert(call.Target);
                foreach (IronPython.Compiler.Ast.Arg arg in call.Args) {

                    if (arg.Name == null)
                        _args.Add(Convert(arg.Expression));
                    else if (arg.Name == "*")
                        _starargs = Convert(arg.Expression);
                    else if (arg.Name == "**")
                        _kwargs = Convert(arg.Expression);
                    else
                        _keywords.Add(new keyword(arg));
                }
            }

            internal static PythonList Convert(ComprehensionIterator[] iters) {
                PythonList comps = new PythonList();
                int start = 1;
                for (int i = 0; i < iters.Length; i++) {
                    if (i == 0 || iters[i] is ComprehensionIf)
                        if (i == iters.Length - 1)
                            i++;
                        else
                            continue;

                    ComprehensionIf[] ifs = new ComprehensionIf[i - start];
                    Array.Copy(iters, start, ifs, 0, ifs.Length);
                    comps.Add(new comprehension((ComprehensionFor)iters[start - 1], ifs));
                    start = i + 1;
                }
                return comps;
            }

 internal comprehension(ComprehensionFor listFor, ComprehensionIf[] listIfs)
     : this() {
     _target = Convert(listFor.Left, Store.Instance);
     _iter = Convert(listFor.List);
     _ifs = PythonOps.MakeEmptyList(listIfs.Length);
     foreach (ComprehensionIf listIf in listIfs)
         _ifs.Add(Convert(listIf.Test));
 }

 internal TryFinally(PythonList body, PythonList finalbody)
     : this() {
     _body = body;
     _finalbody = finalbody;
 }

            internal FunctionDef(FunctionDefinition def)
                : this() {
                _name = def.Name;
                _args = new arguments(def.Parameters);
                _body = ConvertStatements(def.Body);

                if (def.Decorators != null) {
                    _decorators = PythonOps.MakeEmptyList(def.Decorators.Count);
                    foreach (Compiler.Ast.Expression expr in def.Decorators)
                        _decorators.Add(Convert(expr));
                } else
                    _decorators = PythonOps.MakeEmptyList(0);
            }

 internal GeneratorExp(GeneratorExpression expr)
     : this() {
     ExtractListComprehensionIterators walker = new ExtractListComprehensionIterators();
     expr.Function.Body.Walk(walker);
     ComprehensionIterator[] iters = walker.Iterators;
     Debug.Assert(iters.Length != 0, "A generator expression cannot have zero iterators.");
     iters[0] = new ComprehensionFor(((ComprehensionFor)iters[0]).Left, expr.Iterable);
     _elt = Convert(walker.Yield.Expression);
     _generators = Convert(iters);
 }

 internal ExtSlice(PythonList dims)
     : this() {
     _dims = dims;
 }

 internal For(ForStatement stmt)
     : this() {
     _target = Convert(stmt.Left, Store.Instance);
     _iter = Convert(stmt.List);
     _body = ConvertStatements(stmt.Body);
     _orelse = ConvertStatements(stmt.Else, true);
 }

 internal Dict(DictionaryExpression expr)
     : this() {
     _keys = PythonOps.MakeEmptyList(expr.Items.Count);
     _values = PythonOps.MakeEmptyList(expr.Items.Count);
     foreach (SliceExpression item in expr.Items) {
         _keys.Add(Convert(item.SliceStart));
         _values.Add(Convert(item.SliceStop));
     }
 }

 internal Delete(DelStatement stmt)
     : this() {
     _targets = PythonOps.MakeEmptyList(stmt.Expressions.Count);
     foreach (Compiler.Ast.Expression expr in stmt.Expressions)
         _targets.Add(Convert(expr, Del.Instance));
 }

            internal Print(PrintStatement stmt)
                : this() {
                if (stmt.Destination != null)
                    _dest = Convert(stmt.Destination);

                _values = PythonOps.MakeEmptyList(stmt.Expressions.Count);
                foreach (Compiler.Ast.Expression expr in stmt.Expressions)
                    _values.Add(Convert(expr));

                _nl = !stmt.TrailingComma;
            }

 internal Global(GlobalStatement stmt)
     : this() {
     _names = new PythonList(stmt.Names);
 }

            internal TryExcept(TryStatement stmt)
                : this() {
                _body = ConvertStatements(stmt.Body);

                _handlers = PythonOps.MakeEmptyList(stmt.Handlers.Count);
                foreach (TryStatementHandler tryStmt in stmt.Handlers)
                    _handlers.Add(Convert(tryStmt));

                _orelse = ConvertStatements(stmt.Else, true);
            }

            internal Tuple(TupleExpression list, expr_context ctx)
                : this() {
                _elts = PythonOps.MakeEmptyList(list.Items.Count);
                foreach (Compiler.Ast.Expression expr in list.Items)
                    _elts.Add(Convert(expr, ctx));

                _ctx = ctx;
            }

 internal arguments(IList<Parameter> parameters)
     : this() {
     _args = PythonOps.MakeEmptyList(parameters.Count);
     _defaults = PythonOps.MakeEmptyList(parameters.Count);
     foreach (Parameter param in parameters) {
         if (param.IsList)
             _vararg = param.Name;
         else if (param.IsDictionary)
             _kwarg = param.Name;
         else {
             args.Add(new Name(param.Name, Param.Instance));
             if (param.DefaultValue != null)
                 defaults.Add(Convert(param.DefaultValue));
         }
     }
 }

            internal Assign(AssignmentStatement stmt)
                : this() {
                _targets = PythonOps.MakeEmptyList(stmt.Left.Count);
                foreach (Compiler.Ast.Expression expr in stmt.Left)
                    _targets.Add(Convert(expr, Store.Instance));

                _value = Convert(stmt.Right);
            }

 internal ListComp(ListComprehension comp)
     : this() {
     _elt = Convert(comp.Item);
     _generators = Convert(comp.Iterators);
 }

 internal ClassDef(ClassDefinition def)
     : this() {
     _name = def.Name;
     _bases = PythonOps.MakeEmptyList(def.Bases.Count);
     foreach (Compiler.Ast.Expression expr in def.Bases)
         _bases.Add(Convert(expr));
     _body = ConvertStatements(def.Body);
     _decorator_list = new PythonList(); // TODO Actually fill in the decorators here
 }