public FunctionDefinition(string name, Parameter[] parameters, Statement body) {
            ContractUtils.RequiresNotNullItems(parameters, "parameters");

            if (name == null) {
                _name = "<lambda$" + Interlocked.Increment(ref _lambdaId) + ">";
                _isLambda = true;
            } else {
                _name = name;
            }

            _parameters = parameters;
            _body = body;
        }

 public FunctionDefinition(string name, Parameter[] parameters, SourceUnit sourceUnit)
     : this(name, parameters, null, sourceUnit) {
 }

        //  genexpr_for  ::= "for" target_list "in" or_test [genexpr_iter]
        //  genexpr_iter ::= (genexpr_for | genexpr_if) *
        //
        //  "for" has NOT been eaten before entering this method
        private Expression ParseGeneratorExpression(Expression expr) {
            ForStatement root = ParseGenExprFor();
            Statement current = root;

            for (; ; ) {
                if (PeekToken(Tokens.KeywordForToken)) {
                    current = NestGenExpr(current, ParseGenExprFor());
                } else if (PeekToken(Tokens.KeywordIfToken)) {
                    current = NestGenExpr(current, ParseGenExprIf());
                } else {
                    // Generator Expressions have an implicit function definition and yield around their expression.
                    //  (x for i in R)
                    // becomes:
                    //   def f(): 
                    //     for i in R: yield (x)
                    ExpressionStatement ys = new ExpressionStatement(new YieldExpression(expr));
                    ys.Expression.SetLoc(_globalParent, expr.IndexSpan);
                    ys.SetLoc(_globalParent, expr.IndexSpan);
                    NestGenExpr(current, ys);
                    break;
                }
            }

            // We pass the outermost iterable in as a parameter because Python semantics
            // say that this one piece is computed at definition time rather than iteration time
            const string fname = "<genexpr>";
            Parameter parameter = new Parameter("__gen_$_parm__", 0);
            FunctionDefinition func = new FunctionDefinition(fname, new Parameter[] { parameter }, root);
            func.IsGenerator = true;
            func.SetLoc(_globalParent, root.StartIndex, GetEnd());
            func.HeaderIndex = root.EndIndex;

            //  Transform the root "for" statement
            Expression outermost = root.List;
            NameExpression ne = new NameExpression("__gen_$_parm__");
            ne.SetLoc(_globalParent, outermost.IndexSpan);
            root.List = ne;

            GeneratorExpression ret = new GeneratorExpression(func, outermost);
            ret.SetLoc(_globalParent, expr.StartIndex, GetEnd());
            return ret;
        }

 private Parameter ParseParameterName(HashSet<string> names, ParameterKind kind) {
     string name = ReadName();
     if (name != null) {
         CheckUniqueParameter(names, name);
     } else {
         return null;
     }
     Parameter parameter = new Parameter(name, kind);
     parameter.SetLoc(_globalParent, GetStart(), GetEnd());
     return parameter;
 }

 internal arguments(Parameter[] parameters)
     : this(parameters as IList<Parameter>) {
 }

 public override void PostWalk(Parameter node)
 {
 }

        public override bool Walk(Parameter node)
        {
            Content(node.Name);
            Define(node.Name);

            return false;
        }

 private Parameter ParseParameterName(Dictionary<SymbolId, object> names, ParameterKind kind) {
     SymbolId name = ReadName();
     if (name != SymbolId.Empty) {
         CheckUniqueParameter(names, name);
     } else {
         return null;
     }
     Parameter parameter = new Parameter(name, kind);
     parameter.SetLoc(GetStart(), GetEnd());
     return parameter;
 }

 private static Type GetGeneratorDelegateType(Parameter[] parameters, bool wrapper) {
     return PythonCallTargets.GetGeneratorTargetType(wrapper, parameters.Length);
 }

 private static FunctionAttributes ComputeFlags(Parameter[] parameters) {
     FunctionAttributes fa = FunctionAttributes.None;
     if (parameters != null) {
         int i;
         for (i = 0; i < parameters.Length; i++) {
             Parameter p = parameters[i];
             if (p.IsDictionary || p.IsList) break;
         }
         // Check for the list and dictionary parameters, which must be the last(two)
         if (i < parameters.Length && parameters[i].IsList) {
             i++;
             fa |= FunctionAttributes.ArgumentList;
         }
         if (i < parameters.Length && parameters[i].IsDictionary) {
             i++;
             fa |= FunctionAttributes.KeywordDictionary;
         }
         // All parameters must now be exhausted
         if (i < parameters.Length) {
             throw new ArgumentException(IronPython.Resources.InvalidParameters, "parameters");
         }
     }
     return fa;
 }

 public override bool Walk(Parameter node) {
     node.Variable = _binder.DefineParameter(node.Name);
     return false;
 }

 public override bool Walk(Parameter node) {
     _fc.Define(node.Name);
     return true;
 }

        internal static ParameterResult MakeParameterResult(ProjectState state, Parameter curParam)
        {
            string name = curParam.Name;
            if (curParam.IsDictionary) {
                name = "**" + name;
            } else if (curParam.IsList) {
                name = "*" + curParam.Name;
            }

            if (curParam.DefaultValue != null) {
                // TODO: Support all possible expressions for default values, we should
                // probably have a PythonAst walker for expressions or we should add ToCodeString()
                // onto Python ASTs so they can round trip
                ConstantExpression defaultValue = curParam.DefaultValue as ConstantExpression;
                if (defaultValue != null) {
                    name = name + " = " + PythonOps.Repr(state.CodeContext, defaultValue.Value);
                }

                NameExpression nameExpr = curParam.DefaultValue as NameExpression;
                if (nameExpr != null) {
                    name = name + " = " + nameExpr.Name;
                }

                DictionaryExpression dict = curParam.DefaultValue as DictionaryExpression;
                if (dict != null) {
                    if (dict.Items.Count == 0) {
                        name = name + " = {}";
                    } else {
                        name = name + " = {...}";
                    }
                }

                ListExpression list = curParam.DefaultValue as ListExpression;
                if (list != null) {
                    if (list.Items.Count == 0) {
                        name = name + " = []";
                    } else {
                        name = name + " = [...]";
                    }
                }

                TupleExpression tuple = curParam.DefaultValue as TupleExpression;
                if (tuple != null) {
                    if (tuple.Items.Count == 0) {
                        name = name + " = ()";
                    } else {
                        name = name + " = (...)";
                    }
                }
            }

            var newParam = new ParameterResult(name);
            return newParam;
        }

 // Parameter
 public override bool Walk(Parameter node) {
     node.Parent = _currentScope;
     return base.Walk(node);
 }

 private static FunctionAttributes ComputeFlags(Parameter[] parameters) {
     FunctionAttributes fa = FunctionAttributes.None;
     if (parameters != null) {
         int i;
         for (i = 0; i < parameters.Length; i++) {
             Parameter p = parameters[i];
             if (p.IsDictionary || p.IsList) break;
         }
         // Check for the list and dictionary parameters, which must be the last(two)
         if (i < parameters.Length && parameters[i].IsList) {
             i++;
             fa |= FunctionAttributes.ArgumentList;
         }
         if (i < parameters.Length && parameters[i].IsDictionary) {
             i++;
             fa |= FunctionAttributes.KeywordDictionary;
         }
         
         // All parameters must now be exhausted
         Debug.Assert(i == parameters.Length);
     }
     return fa;
 }

 internal Parameter[] Revert()
 {
     List<Parameter> parameters = new List<Parameter>();
     int argIdx = args.Count - 1;
     for (int defIdx = defaults.Count - 1; defIdx >= 0; defIdx--, argIdx--) {
         Name name = (Name)args[argIdx];
         Parameter p = new Parameter(name.id);
         p.DefaultValue = expr.Revert(defaults[defIdx]);
         parameters.Add(p);
     }
     while (argIdx >= 0) {
         Name name = (Name)args[argIdx--];
         parameters.Add(new Parameter(name.id));
     }
     parameters.Reverse();
     if (vararg != null)
         parameters.Add(new Parameter(vararg, ParameterKind.List));
     if (kwarg != null)
         parameters.Add(new Parameter(kwarg, ParameterKind.Dictionary));
     return parameters.ToArray();
 }

 internal Name(Parameter para)
     : this(para.Name, Param.Instance)
 {
     GetSourceLocation(para);
 }

 public FunctionDefinition(SymbolId name, Parameter[] parameters, SourceUnit sourceUnit)
     : this(name, parameters, null, sourceUnit) {
 }

        //  parameter ::=
        //      identifier | "(" sublist ")"
        Parameter ParseParameter(int position, Dictionary<SymbolId, object> names) {
            Token t = PeekToken();
            Parameter parameter = null;

            switch (t.Kind) {
                case TokenKind.LeftParenthesis: // sublist
                    NextToken();
                    Expression ret = ParseSublist(names);
                    Eat(TokenKind.RightParenthesis);
                    TupleExpression tret = ret as TupleExpression;

                    if (tret != null) {
                        parameter = new SublistParameter(position, tret);
                    } else {
                        parameter = new Parameter(((NameExpression)ret).Name);
                    }
                    parameter.SetLoc(ret.Span);
                    break;

                case TokenKind.Name:  // identifier
                    NextToken();
                    SymbolId name = FixName((SymbolId)t.Value);
                    parameter = new Parameter(name);
                    CompleteParameterName(parameter, name, names);
                    break;

                default:
                    ReportSyntaxError(_lookahead);
                    break;
            }

            return parameter;
        }

        private void AddOptinonalParam(StringBuilder sb, Parameter p)
        {
            JavascriptGenerator gen = new JavascriptGenerator(src, sink);
            p.DefaultValue.Walk(gen);

            sb.AppendFormat("{0}if (typeof({1}) == 'undefined') {{",
                Indent(),
                p.Name
            );
            sb.AppendLine();

            sb.AppendFormat("{0}{1} = {2};",
                Indent(indent + 1),
                p.Name,
                gen.ToString()
            );
            sb.AppendLine();

            sb.AppendFormat("{0}}}", Indent());
            sb.AppendLine();
        }