@@ -428,13 +428,13 @@ public abstract class AST
         public class alias : AST
         {
             private string _name;
-            private string _asname;
+            private string _asname;  // Optional
 
             public alias() {
                 _fields = new PythonTuple(new[] { "name", "asname" });
             }
 
-            internal alias(string name, string asname)
+            internal alias(string name, [Optional]string asname)
                 : this() {
                 _name = name;
                 _asname = asname;
@@ -455,14 +455,22 @@ internal alias(string name, string asname)
         public class arguments : AST
         {
             private PythonList _args;
-            private string _vararg;
-            private string _kwarg;
+            private string _vararg; // Optional
+            private string _kwarg; // Optional
             private PythonList _defaults;
 
             public arguments() {
                 _fields = new PythonTuple(new[] { "args", "vararg", "kwarg", "defaults" });
             }
 
+            public arguments(PythonList args, [Optional]string vararg, [Optional]string kwarg, PythonList defaults)
+                :this() {
+                _args = args;
+                _vararg = vararg;
+                _kwarg = kwarg;
+                _kwarg = kwarg;
+                _defaults = defaults;
+            }
 
             internal arguments(IList<Parameter> parameters)
                 : this() {
@@ -528,6 +536,13 @@ public class comprehension : AST
                 _fields = new PythonTuple(new[] { "target", "iter", "ifs" });
             }
 
+            public comprehension(expr target, expr iter, PythonList ifs)
+                : this() {
+                _target = target;
+                _iter = iter;
+                _ifs = ifs;
+            }
+
             internal comprehension(ComprehensionFor listFor, ComprehensionIf[] listIfs)
                 : this() {
                 _target = Convert(listFor.Left, Store.Instance);
@@ -604,6 +619,12 @@ public class keyword : AST
                 _fields = new PythonTuple(new[] { "arg", "value" });
             }
 
+            public keyword(string arg, expr value)
+                : this() {
+                _arg = arg;
+                _value = value;
+            }
+
             internal keyword(IronPython.Compiler.Ast.Arg arg)
                 : this() {
                 _arg = arg.Name;
@@ -682,6 +703,14 @@ public class Assert : stmt
                 _fields = new PythonTuple(new[] { "test", "msg" });
             }
 
+            public Assert(expr test, expr msg, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _test = test;
+                _msg = msg;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Assert(AssertStatement stmt)
                 : this() {
                 _test = Convert(stmt.Test);
@@ -710,6 +739,14 @@ public class Assign : stmt
                 _fields = new PythonTuple(new[] { "targets", "value" });
             }
 
+            public Assign(PythonList targets, expr value, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _targets = targets;
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Assign(AssignmentStatement stmt)
                 : this() {
                 _targets = PythonOps.MakeEmptyList(stmt.Left.Count);
@@ -741,6 +778,16 @@ public class Attribute : expr
                 _fields = new PythonTuple(new[] { "value", "attr", "ctx" });
             }
 
+            public Attribute(expr value, string attr, expr_context ctx,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _value = value;
+                _attr = attr;
+                _ctx = ctx;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Attribute(MemberExpression attr, expr_context ctx)
                 : this() {
                 _value = Convert(attr.Target);
@@ -775,6 +822,16 @@ public class AugAssign : stmt
                 _fields = new PythonTuple(new[] { "target", "op", "value" });
             }
 
+            public AugAssign(expr target, @operator op, expr value,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _target = target;
+                _op = op;
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal AugAssign(AugmentedAssignStatement stmt)
                 : this() {
                 _target = Convert(stmt.Left, Store.Instance);
@@ -825,14 +882,13 @@ public class BinOp : expr
                 _fields = new PythonTuple(new[] { "left", "op", "right" });
             }
 
-            public BinOp(expr left, @operator op, expr right, [Optional]int? lineno)
+            public BinOp(expr left, @operator op, expr right, [Optional]int lineno, [Optional]int col_offset)
                 : this() {
                 _left = left;
                 _op = op;
                 _right = right;
-
-                if (lineno != null)
-                    this.lineno = lineno.Value;
+                _lineno = lineno;
+                _col_offset = col_offset;
             }
 
             internal BinOp(BinaryExpression expr, @operator op)
@@ -886,6 +942,14 @@ public class BoolOp : expr
                 _fields = new PythonTuple(new[] { "op", "values" });
             }
 
+            public BoolOp(boolop op, PythonList values, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _op = op;
+                _values = values;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal BoolOp(AndExpression and)
                 : this() {
                 _values = PythonOps.MakeListNoCopy(Convert(and.Left), Convert(and.Right));
@@ -913,6 +977,11 @@ internal BoolOp(OrExpression or)
         public class Break : stmt
         {
             internal static Break Instance = new Break();
+
+            public Break([Optional]int lineno, [Optional]int col_offset) {
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
         }
 
         [PythonType]
@@ -928,6 +997,19 @@ public class Call : expr
                 _fields = new PythonTuple(new[] { "func", "args", "keywords", "starargs", "kwargs" });
             }
 
+            public Call( expr func, PythonList args, PythonList keywords, 
+                [Optional]expr starargs, [Optional]expr kwargs,
+                [Optional]int lineno, [Optional]int col_offset) 
+                :this() {
+                _func = func;
+                _args = args;
+                _keywords = keywords;
+                _starargs = starargs;
+                _kwargs = kwargs;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Call(CallExpression call)
                 : this() {
                 _args = PythonOps.MakeEmptyList(call.Args.Count);
@@ -984,6 +1066,18 @@ public class ClassDef : stmt
                 _fields = new PythonTuple(new[] { "name", "bases", "body", "decorator_list" });
             }
 
+            public ClassDef(string name, PythonList bases, PythonList body, PythonList decorator_list,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _name = name;
+                _bases = bases;
+                _body = body;
+                _decorator_list = decorator_list;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+
             internal ClassDef(ClassDefinition def)
                 : this() {
                 _name = def.Name;
@@ -1026,6 +1120,16 @@ public class Compare : expr
                 _fields = new PythonTuple(new[] { "left", "ops", "comparators" });
             }
 
+            public Compare(expr left, PythonList ops, PythonList comparators, 
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _left = left;
+                _ops = ops;
+                _comparators = comparators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Compare(BinaryExpression expr, cmpop op)
                 : this() {
                 _left = Convert(expr.Left);
@@ -1053,6 +1157,11 @@ internal Compare(BinaryExpression expr, cmpop op)
         public class Continue : stmt
         {
             internal static Continue Instance = new Continue();
+
+            public Continue([Optional]int lineno, [Optional]int col_offset) {
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
         }
 
         [PythonType]
@@ -1070,6 +1179,13 @@ public class Delete : stmt
                 _fields = new PythonTuple(new[] { "targets", });
             }
 
+            public Delete(PythonList targets, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _targets = targets;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Delete(DelStatement stmt)
                 : this() {
                 _targets = PythonOps.MakeEmptyList(stmt.Expressions.Count);
@@ -1093,6 +1209,14 @@ public class Dict : expr
                 _fields = new PythonTuple(new[] { "keys", "values" });
             }
 
+            public Dict(PythonList keys, PythonList values, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _keys = keys;
+                _values = values;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Dict(DictionaryExpression expr)
                 : this() {
                 _keys = PythonOps.MakeEmptyList(expr.Items.Count);
@@ -1114,6 +1238,50 @@ internal Dict(DictionaryExpression expr)
             }
         }
 
+        [PythonType]
+        public class DictComp : expr {
+            private expr _key;
+            private expr _value;
+            private PythonList _generators;
+
+            public DictComp() {
+                _fields = new PythonTuple(new[] { "key", "value", "generators" });
+            }
+
+            public DictComp(expr key, expr value, PythonList generators, 
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _key = key;
+                _value = value;
+                _generators = generators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+            internal DictComp(DictionaryComprehension comp)
+                : this() {
+                _key = Convert(comp.Key);
+                _value = Convert(comp.Value);
+                _generators = Convert(comp.Iterators);
+            }
+
+            public expr key {
+                get { return _key; }
+                set { _key = value; }
+            }
+
+            public expr value {
+                get { return _value; }
+                set { _value = value; }
+            }
+
+            public PythonList generators {
+                get { return _generators; }
+                set { _generators = value; }
+            }
+        }
+
+
         [PythonType]
         public class Div : @operator
         {
@@ -1143,6 +1311,16 @@ public class ExceptHandler : excepthandler
                 _fields = new PythonTuple(new[] { "type", "name", "body" });
             }
 
+            public ExceptHandler([Optional]expr type, [Optional]expr name, PythonList body,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _type = type;
+                _name = name;
+                _body = body;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal ExceptHandler(TryStatementHandler stmt)
                 : this() {
                 if (stmt.Test != null)
@@ -1180,6 +1358,17 @@ public class Exec : stmt
                 _fields = new PythonTuple(new[] { "body", "globals", "locals" });
             }
 
+            public Exec(expr body, [Optional]expr globals, [Optional]expr locals,
+               [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _body = body;
+                _globals = globals;
+                _locals = locals;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+
             public Exec(ExecStatement stmt)
                 : this() {
                 _body = Convert(stmt.Code);
@@ -1214,6 +1403,13 @@ public class Expr : stmt
                 _fields = new PythonTuple(new[] { "value", });
             }
 
+            public Expr(expr value, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Expr(ExpressionStatement stmt)
                 : this() {
                 _value = Convert(stmt.Expression);
@@ -1234,6 +1430,11 @@ public class Expression : mod
                 _fields = new PythonTuple(new[] { "body", });
             }
 
+            public Expression(expr body)
+                : this() {
+                _body = body;
+            }
+
             internal Expression(SuiteStatement suite)
                 : this() {
                 _body = Convert(((ExpressionStatement)suite.Statements[0]).Expression);
@@ -1258,7 +1459,7 @@ public class ExtSlice : slice
                 _fields = new PythonTuple(new[] { "dims", });
             }
 
-            internal ExtSlice(PythonList dims)
+            public ExtSlice(PythonList dims)
                 : this() {
                 _dims = dims;
             }
@@ -1287,6 +1488,20 @@ public class For : stmt
                 _fields = new PythonTuple(new[] { "target", "iter", "body", "orelse" });
             }
 
+            public For(expr target, expr iter, PythonList body, [Optional]PythonList orelse,
+               [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _target = target;
+                _iter = iter;
+                _body = body;
+                if (null == orelse)
+                    _orelse = new PythonList();
+                else
+                    _orelse = orelse;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal For(ForStatement stmt)
                 : this() {
                 _target = Convert(stmt.Left, Store.Instance);
@@ -1328,6 +1543,17 @@ public class FunctionDef : stmt
                 _fields = new PythonTuple(new[] { "name", "args", "body", "decorators" });
             }
 
+            public FunctionDef(string name, arguments args, PythonList body, PythonList decorators,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _name = name;
+                _args = args;
+                _body = body;
+                _decorators = decorators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal FunctionDef(FunctionDefinition def)
                 : this() {
                 _name = def.Name;
@@ -1373,6 +1599,14 @@ public class GeneratorExp : expr
                 _fields = new PythonTuple(new[] { "elt", "generators" });
             }
 
+            public GeneratorExp(expr elt, PythonList generators, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elt = elt;
+                _generators = generators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal GeneratorExp(GeneratorExpression expr)
                 : this() {
                 ExtractListComprehensionIterators walker = new ExtractListComprehensionIterators();
@@ -1432,6 +1666,13 @@ public class Global : stmt
                 _fields = new PythonTuple(new[] { "names", });
             }
 
+            public Global(PythonList names, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _names = names;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Global(GlobalStatement stmt)
                 : this() {
                 _names = new PythonList(stmt.Names);
@@ -1466,6 +1707,17 @@ public class If : stmt
                 _fields = new PythonTuple(new[] { "test", "body", "orelse" });
             }
 
+            public If(expr test, PythonList body, [Optional]PythonList orelse, 
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _test = test;
+                _body = body;
+                if (null == orelse)
+                    _orelse = new PythonList();
+                else
+                    _orelse = orelse;
+            }
+
             internal If(IfStatement stmt)
                 : this() {
                 If current = this;
@@ -1515,6 +1767,15 @@ public class IfExp : expr
                 _fields = new PythonTuple(new[] { "test", "body", "orelse" });
             }
 
+            public IfExp(expr test, expr body, expr orelse, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _test = test;
+                _body = body;
+                _orelse = orelse;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal IfExp(ConditionalExpression cond)
                 : this() {
                 _test = Convert(cond.Test);
@@ -1547,6 +1808,13 @@ public class Import : stmt
                 _fields = new PythonTuple(new[] { "names", });
             }
 
+            public Import(PythonList names, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _names = names;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Import(ImportStatement stmt)
                 : this() {
                 _names = ConvertAliases(stmt.Names, stmt.AsNames);
@@ -1561,14 +1829,24 @@ internal Import(ImportStatement stmt)
         [PythonType]
         public class ImportFrom : stmt
         {
-            private string _module;
+            private string _module; // Optional
             private PythonList _names;
             private int _level; // Optional, default 0
 
             public ImportFrom() {
                 _fields = new PythonTuple(new[] { "module", "names", "level" });
             }
 
+            public ImportFrom([Optional]string module, PythonList names, [Optional]int level,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _module = module;
+                _names = names;
+                _level = level;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             public ImportFrom(FromImportStatement stmt)
                 : this() {
                 _module = stmt.Root.MakeString();
@@ -1609,9 +1887,9 @@ public class Index : slice
                 _fields = new PythonTuple(new[] { "value", });
             }
 
-            internal Index(expr expr)
+            public Index(expr value)
                 : this() {
-                _value = expr;
+                _value = value;
             }
 
             public expr value {
@@ -1629,6 +1907,11 @@ public class Interactive : mod
                 _fields = new PythonTuple(new[] { "body", });
             }
 
+            public Interactive(PythonList body)
+                : this() {
+                _body = body;
+            }
+
             internal Interactive(SuiteStatement suite)
                 : this() {
                 _body = ConvertStatements(suite);
@@ -1672,6 +1955,14 @@ public class Lambda : expr
                 _fields = new PythonTuple(new[] { "args", "body" });
             }
 
+            public Lambda(arguments args, expr body, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _args = args;
+                _body = body;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Lambda(LambdaExpression lambda)
                 : this() {
                 FunctionDef def = (FunctionDef)Convert(lambda.Function);
@@ -1701,6 +1992,14 @@ public class List : expr
                 _fields = new PythonTuple(new[] { "elts", "ctx" });
             }
 
+            public List(PythonList elts, expr_context ctx, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elts = elts;
+                _ctx = ctx;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal List(ListExpression list, expr_context ctx)
                 : this() {
                 _elts = PythonOps.MakeEmptyList(list.Items.Count);
@@ -1731,6 +2030,14 @@ public class ListComp : expr
                 _fields = new PythonTuple(new[] { "elt", "generators" });
             }
 
+            public ListComp(expr elt, PythonList generators, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elt = elt;
+                _generators = generators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal ListComp(ListComprehension comp)
                 : this() {
                 _elt = Convert(comp.Item);
@@ -1787,6 +2094,11 @@ public class Module : mod
                 _fields = new PythonTuple(new[] { "body", });
             }
 
+            public Module(PythonList body)
+                : this() {
+                _body = body;
+            }
+
             internal Module(SuiteStatement suite)
                 : this() {
                 _body = ConvertStatements(suite);
@@ -1818,14 +2130,16 @@ public class Name : expr
                 _fields = new PythonTuple(new[] { "id", "ctx" });
             }
 
-            internal Name(NameExpression expr, expr_context ctx)
-                : this(expr.Name, ctx) {
-            }
-
-            internal Name(string id, expr_context ctx)
+            public Name(string id, expr_context ctx, [Optional]int lineno, [Optional]int col_offset)
                 : this() {
                 _id = id;
                 _ctx = ctx;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+            internal Name(NameExpression expr, expr_context ctx)
+                : this(expr.Name, ctx) {
             }
 
             public expr_context ctx {
@@ -1866,9 +2180,11 @@ public class Num : expr
                 _fields = new PythonTuple(new[] { "n", });
             }
 
-            internal Num(object n)
+            public Num(object n, [Optional]int lineno, [Optional]int col_offset)
                 : this() {
                 _n = n;
+                _lineno = lineno;
+                _col_offset = col_offset;
             }
 
             public object n {
@@ -1893,6 +2209,11 @@ public class Param : expr_context
         public class Pass : stmt
         {
             internal static Pass Instance = new Pass();
+
+            public Pass([Optional]int lineno, [Optional]int col_offset) {
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
         }
 
         [PythonType]
@@ -1904,14 +2225,24 @@ public class Pow : @operator
         [PythonType]
         public class Print : stmt
         {
-            private expr _dest;
+            private expr _dest; // optional
             private PythonList _values;
             private bool _nl;
 
             public Print() {
                 _fields = new PythonTuple(new[] { "dest", "values", "nl" });
             }
 
+            public Print([Optional]expr dest, PythonList values, bool nl,
+               [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _dest = dest;
+                _values = values;
+                _nl = nl;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Print(PrintStatement stmt)
                 : this() {
                 if (stmt.Destination != null)
@@ -1951,6 +2282,16 @@ public class Raise : stmt
                 _fields = new PythonTuple(new[] { "type", "inst", "tback" });
             }
 
+            public Raise([Optional]expr type, [Optional]expr inst, [Optional]expr tback,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _type = type;
+                _inst = inst;
+                _tback = tback;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Raise(RaiseStatement stmt)
                 : this() {
                 if (stmt.ExceptType != null)
@@ -1986,6 +2327,13 @@ public class Repr : expr
                 _fields = new PythonTuple(new[] { "value", });
             }
 
+            public Repr(expr value, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Repr(BackQuoteExpression expr)
                 : this() {
                 _value = Convert(expr.Expression);
@@ -2006,6 +2354,13 @@ public class Return : stmt
                 _fields = new PythonTuple(new[] { "value", });
             }
 
+            public Return([Optional]expr value, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             public Return(ReturnStatement statement)
                 : this() {
                 // statement.Expression is never null
@@ -2028,6 +2383,64 @@ public class RShift : @operator
             internal static RShift Instance = new RShift();
         }
 
+        [PythonType]
+        public class Set : expr {
+            private PythonList _elts;
+
+            public Set() {
+                _fields = new PythonTuple(new[] { "elts" });
+            }
+
+            public Set(PythonList elts, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elts = elts;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+            // TODO: Convert is missing
+
+            public PythonList elts {
+                get { return _elts; }
+                set { _elts = value; }
+            }
+        }
+
+        [PythonType]
+        public class SetComp : expr {
+            private expr _elt;
+            private PythonList _generators;
+
+            public SetComp() {
+                _fields = new PythonTuple(new[] { "elt", "generators" });
+            }
+
+            public SetComp(expr elt, PythonList generators, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elt = elt;
+                _generators = generators;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+            internal SetComp(SetComprehension comp)
+                : this() {  
+                _elt = Convert(comp.Item);
+                _generators = Convert(comp.Iterators);
+            }
+
+            public expr elt {
+                get { return _elt; }
+                set { _elt = value; }
+            }
+
+            public PythonList generators {
+                get { return _generators; }
+                set { _generators = value; }
+            }
+        }
+
+
         [PythonType]
         public class Slice : slice
         {
@@ -2039,7 +2452,14 @@ public class Slice : slice
                 _fields = new PythonTuple(new[] { "lower", "upper", "step" });
             }
 
-            public Slice(SliceExpression expr)
+            public Slice([Optional]expr lower, [Optional]expr upper, [Optional]expr step)
+                : this() {
+                _lower = lower;
+                _upper = upper;
+                _step = step;
+            }
+
+            internal Slice(SliceExpression expr)
                 : this() {
                 if (expr.SliceStart != null)
                     _lower = Convert(expr.SliceStart);
@@ -2080,9 +2500,11 @@ public class Str : expr
                 _fields = new PythonTuple(new[] { "s", });
             }
 
-            internal Str(string s)
+            public Str(string s, [Optional]int lineno, [Optional]int col_offset)
                 : this() {
                 _s = s;
+                _lineno = lineno;
+                _col_offset = col_offset;
             }
 
             public string s {
@@ -2108,6 +2530,16 @@ public class Subscript : expr
                 _fields = new PythonTuple(new[] { "value", "slice", "ctx" });
             }
 
+            public Subscript( expr value, slice slice, expr_context ctx, 
+                [Optional]int lineno, [Optional]int col_offset )
+                : this() {
+                _value = value;
+                _slice = slice;
+                _ctx = ctx;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Subscript(IndexExpression expr, expr_context ctx)
                 : this() {
                 _value = Convert(expr.Target);
@@ -2153,6 +2585,11 @@ public class Suite : mod
                 _fields = new PythonTuple(new[] { "body", });
             }
 
+            public Suite(PythonList body)
+                : this() {
+                _body = body;
+            }
+
             public PythonList body {
                 get { return _body; }
                 set { _body = value; }
@@ -2174,6 +2611,20 @@ public class TryExcept : stmt
                 _fields = new PythonTuple(new[] { "body", "handlers", "orelse" });
             }
 
+            public TryExcept(PythonList body, PythonList handlers, [Optional]PythonList orelse,
+                [Optional]int lineno, [Optional]int col_offset ) 
+                : this() {
+                _body = body;
+                _handlers = handlers;
+                if (null == orelse)
+                    _orelse = new PythonList();
+                else
+                    _orelse = orelse;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+
             internal TryExcept(TryStatement stmt)
                 : this() {
                 _body = ConvertStatements(stmt.Body);
@@ -2211,6 +2662,16 @@ public class TryFinally : stmt
                 _fields = new PythonTuple(new[] { "body", "finalbody" });
             }
 
+            public TryFinally(PythonList body, PythonList finalBody, 
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _body = body;
+                _finalbody = finalbody;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
+
             internal TryFinally(PythonList body, PythonList finalbody)
                 : this() {
                 _body = body;
@@ -2238,6 +2699,14 @@ public class Tuple : expr
                 _fields = new PythonTuple(new[] { "elts", "ctx" });
             }
 
+            public Tuple(PythonList elts, expr_context ctx, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _elts = elts;
+                _ctx = ctx;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Tuple(TupleExpression list, expr_context ctx)
                 : this() {
                 _elts = PythonOps.MakeEmptyList(list.Items.Count);
@@ -2274,6 +2743,14 @@ internal UnaryOp(UnaryExpression expression)
                 _operand = Convert(expression.Expression);
             }
 
+            public UnaryOp(unaryop op, expr operand, [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _op = op;
+                _operand = operand;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             public unaryop op {
                 get { return _op; }
                 set { _op = value; }
@@ -2308,6 +2785,19 @@ public class While : stmt
                 _fields = new PythonTuple(new[] { "test", "body", "orelse" });
             }
 
+            public While(expr test, PythonList body, [Optional]PythonList orelse,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _test = test;
+                _body = body;
+                if (null == orelse)
+                    _orelse = new PythonList();
+                else
+                    _orelse = orelse;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal While(WhileStatement stmt)
                 : this() {
                 _test = Convert(stmt.Test);
@@ -2342,6 +2832,16 @@ public class With : stmt
                 _fields = new PythonTuple(new[] { "context_expr", "optional_vars", "body" });
             }
 
+            public With(expr context_expr, [Optional]expr optional_vars, PythonList body,
+                [Optional]int lineno, [Optional]int col_offset)
+                : this() {
+                _context_expr = context_expr;
+                _optional_vars = optional_vars;
+                _body = body;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal With(WithStatement with)
                 : this() {
                 _context_expr = Convert(with.ContextManager);
@@ -2376,6 +2876,13 @@ public class Yield : expr
                 _fields = new PythonTuple(new[] { "value", });
             }
 
+            public Yield([Optional]expr value, [Optional]int lineno, [Optional]int col_offset) 
+                : this() {
+                _value = value;
+                _lineno = lineno;
+                _col_offset = col_offset;
+            }
+
             internal Yield(YieldExpression expr)
                 : this() {
                 // expr.Expression is never null