public string Visit(PyAst.LambdaExpression node) { var args = string.Join(", ", node.Function.Parameters.Select(p => Visit(p))); var convertedExpr = Visit(((PyAst.ReturnStatement)node.Function.Body).Expression); return($"lambda { args }: {convertedExpr}"); }
public Node VisitExpression(IronPython.Compiler.Ast.LambdaExpression exp) { var changed = false; var newCode = exp; foreach (var edit in _edits) { if (edit.CanApply(exp)) { changed = true; if (edit is Update) { newCode = (IronPython.Compiler.Ast.LambdaExpression)edit.ModifiedNode.InnerNode; } else if (edit is Insert) { throw new NotImplementedException(); } else { throw new NotImplementedException(); } } } if (changed) { return(newCode); } return(new IronPython.Compiler.Ast.LambdaExpression(newCode.Function)); }
private Expression ParseLambdaHelperEnd(FunctionDefinition func, Expression expr) { // Pep 342 in Python 2.5 allows Yield Expressions, which can occur inside a Lambda body. // In this case, the lambda is a generator and will yield it's final result instead of just return it. Statement body; if (func.IsGenerator) { YieldExpression y = new YieldExpression(expr); y.SetLoc(_globalParent, expr.IndexSpan); body = new ExpressionStatement(y); } else { body = new ReturnStatement(expr); } body.SetLoc(_globalParent, expr.StartIndex, expr.EndIndex); FunctionDefinition func2 = PopFunction(); System.Diagnostics.Debug.Assert(func == func2); func.Body = body; func.EndIndex = GetEnd(); LambdaExpression ret = new LambdaExpression(func); func.SetLoc(_globalParent, func.IndexSpan); ret.SetLoc(_globalParent, func.IndexSpan); return ret; }
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; }
public override void PostWalk(LambdaExpression node) { CommonPostWalk(node); }
public override bool Walk(LambdaExpression node) { CommonWalk(node); return true; }
// LambdaExpression public bool Walk(LambdaExpression node) { return Process(node); }
public void PostWalk(LambdaExpression node) { PostProcess(node); }
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 statement."); stmt statement = (stmt)def.body[0]; if (statement is Return) _body = ((Return)statement).value; else if (statement is Expr) { // What should be sufficient is: // _body = ((Expr)statement).value; // but, AST comes with trees containing twice YieldExpression. // For: // lamba x: (yield x) // it comes back with: // //IronPython.Compiler.Ast.LambdaExpression //IronPython.Compiler.Ast.FunctionDefinition<lambda$334>generator // IronPython.Compiler.Ast.Parameter x // IronPython.Compiler.Ast.ExpressionStatement // IronPython.Compiler.Ast.YieldExpression <<<<<<<< // IronPython.Compiler.Ast.YieldExpression <<<<<<<< why twice? // IronPython.Compiler.Ast.NameExpression x _body = ((Yield)((Expr)statement).value).value; } else throw PythonOps.TypeError("Unexpected statement type: {0}, expected Return or Expr", statement.GetType()); }
private static ISet<Namespace> MakeLambdaFunction(LambdaExpression node, ExpressionEvaluator ee) { return ee.GlobalScope.NodeVariables[node.Function]; }
// LambdaExpr public override bool Walk(LambdaExpression node) { return false; }
public override bool Walk(LambdaExpression node) { return base.Walk(node); }
public virtual void PostWalk(LambdaExpression node) { }
// LambdaExpression public virtual bool Walk(LambdaExpression node) { return true; }
private Expression FinishOldLambdef() { Location start = GetStart(); Expression[] parameters, defaults; FunctionAttributes flags; ParseVarArgsList(out parameters, out defaults, out flags, TokenKind.Colon); Location mid = GetEnd(); Expression expr = ParseOldTest(); Statement body = new ReturnStatement(expr); body.SetLoc(GetExternal(), expr.Start, expr.End); FunctionDefinition func = new FunctionDefinition(SymbolTable.StringToId("<lambda$" + (oldLambdaCount++) + ">"), parameters, defaults, flags, body, context.SourceFile); func.SetLoc(GetExternal(), start, GetEnd()); func.Header = mid; LambdaExpression ret = new LambdaExpression(func); ret.SetLoc(GetExternal(), start, GetEnd()); return ret; }