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);
 }

 private void GenerateExpr(expr expr, ILGenerator ilGenerator)
 {
     if (expr is int_lit)
     {
         int_lit e = expr as int_lit;
         ilGenerator.Emit(OpCodes.Ldc_I4, e.value);
     }
     else if (expr is float_lit)
     {
         float_lit e = expr as float_lit;
         ilGenerator.Emit(OpCodes.Ldc_R4, e.value);
     }
     else if (expr is bool_lit)
     {
         bool_lit e = expr as bool_lit;
         ilGenerator.Emit(OpCodes.Ldc_I4, (e.value ? 1 : 0));
     }
     else if (expr is string_lit)
     {
         string_lit e = expr as string_lit;
         ilGenerator.Emit(OpCodes.Ldstr, e.value);
     }
     else if (expr is byte_lit)
     {
         byte_lit e = expr as byte_lit;
         ilGenerator.Emit(OpCodes.Ldc_I4, e.value);
     }
     else if (expr is getvar)
     {
         getvar e = expr as getvar;
         LoadLocal(e.name, ilGenerator);
     }
 }

 private Type[] GetExprTypes(expr expr)
 {
     if (expr is expr_list)
     {
         return (expr as expr_list).list.Select(e => GetExprType(e)).ToArray();
     }
     else if (expr == null)
     {
         return null;
     }
     else
     {
         return new Type[] { GetExprType(expr) };
     }
 }

 internal BinOp(BinaryExpression expr, @operator op)
     : this() {
     _left = Convert(expr.Left);
     _right = Convert(expr.Right);
     _op = op;
 }

            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 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 Index(expr expr)
     : this() {
     _value = expr;
 }

 internal Yield(YieldExpression expr)
     : this() {
     // expr.Expression is never null
     _value = Convert(expr.Expression);
 }

 internal Repr(BackQuoteExpression expr)
     : this() {
     _value = Convert(expr.Expression);
 }

 public Slice(SliceExpression expr)
     : this() {
     if (expr.SliceStart != null)
         _lower = Convert(expr.SliceStart);
     if (expr.SliceStop != null)
         _upper = Convert(expr.SliceStop);
     if (expr.StepProvided && expr.SliceStep != null)
         _step = Convert(expr.SliceStep);
 }

 internal Attribute(MemberExpression attr, expr_context ctx)
     : this() {
     _value = Convert(attr.Target);
     _attr = attr.Name;
     _ctx = ctx;
 }

            internal Subscript(IndexExpression expr, expr_context ctx)
                : this() {
                _value = Convert(expr.Target);
                AST index = Convert(expr.Index);
                if (index is expr)
                    if (index is Tuple && ((TupleExpression)expr.Index).IsExpandable)
                        _slice = new ExtSlice(((Tuple)index).elts);
                    else
                        _slice = new Index((expr)index);
                else if (index is slice) // includes Ellipsis
                    _slice = (slice)index;
                else
                    throw new ArgumentTypeException("Unexpected index expression: " + expr.Index.GetType());

                _ctx = ctx;
            }

 internal UnaryOp(UnaryExpression expression)
     : this() {
     _op = (unaryop)Convert(expression.Op);
     _operand = Convert(expression.Expression);
 }

 private Type GetExprType(expr e)
 {
     if (e is int_lit)
     {
         return typeof(int);
     }
     else if (e is float_lit)
     {
         return typeof(float);
     }
     else if (e is bool_lit)
     {
         return typeof(bool);
     }
     else if (e is byte_lit)
     {
         return typeof(byte);
     }
     else if (e is string_lit)
     {
         return typeof(string);
     }
     else if (e is getvar)
     {
         return GetVarType(e);
     }
     else if (e is function_call)
     {
         function_call stmt = e as function_call;
         return GetMethodInfo(stmt.name, null, null, GetMethodTypes(stmt.name, null, GetExprTypes(stmt.arg))).ReturnType;
     }
     else if (e == null)
     {
         return null;
     }
     else
     {
         throw new Exception("Cannot find argument type");
     }
 }

            internal With(WithStatement with)
                : this() {
                _context_expr = Convert(with.ContextManager);
                if (with.Variable != null)
                    _optional_vars = Convert(with.Variable);

                _body = ConvertStatements(with.Body);
            }

 private Type GetVarType(expr e)
 {
     throw new NotImplementedException();
 }

 internal AugAssign(AugmentedAssignStatement stmt)
     : this() {
     _target = Convert(stmt.Left, Store.Instance);
     _value = Convert(stmt.Right);
     _op = (@operator)Convert(stmt.Operator);
 }

 internal keyword(IronPython.Compiler.Ast.Arg arg)
     : this() {
     _arg = arg.Name;
     _value = Convert(arg.Expression);
 }

 internal Raise(RaiseStatement stmt)
     : this() {
     if (stmt.ExceptType != null)
         _type = Convert(stmt.ExceptType);
     if (stmt.Value != null)
         _inst = Convert(stmt.Value);
     if (stmt.Traceback != null)
         _tback = Convert(stmt.Traceback);
 }

 internal Lambda(LambdaExpression lambda)
     : this() {
     FunctionDef def = (FunctionDef)Convert(lambda.Function);
     _args = def.args;
     Debug.Assert(def.body.Count == 1, "LambdaExpression body should be one Return statement.");
     _body = ((Return)def.body[0]).value;
 }