Lambda and varargs

ncw · ncw · commit 0079df44e854 · 2014-11-28T23:12:00.000Z
diff --git a/ast/ast.go b/ast/ast.go
@@ -650,11 +650,11 @@ type ExceptHandler struct {
 
 type Arguments struct {
 	Pos
-	Args       []Arg
-	Vararg     Arg
-	Kwonlyargs []Arg
+	Args       []*Arg
+	Vararg     *Arg
+	Kwonlyargs []*Arg
 	KwDefaults []Expr
-	Kwarg      Arg
+	Kwarg      *Arg
 	Defaults   []Expr
 }
 
diff --git a/ast/dump.go b/ast/dump.go
@@ -26,6 +26,16 @@ func dumpItem(v interface{}) string {
 		return dump(x, "keyword")
 	case *WithItem:
 		return dump(x, "withitem")
+	case *Arguments:
+		if x == nil {
+			return "None"
+		}
+		return dump(x, "arguments")
+	case *Arg:
+		if x == nil {
+			return "None"
+		}
+		return dump(x, "arg")
 	case ModBase:
 	case StmtBase:
 	case ExprBase:
@@ -61,6 +71,8 @@ func dump(ast interface{}, name string) string {
 			fname = "context_expr"
 		case "optionalvars":
 			fname = "optional_vars"
+		case "kwdefaults":
+			fname = "kw_defaults"
 		}
 		if fieldValue.Kind() == reflect.Slice && fieldValue.Type().Elem().Kind() != reflect.Uint8 {
 			strs := make([]string, fieldValue.Len())
diff --git a/parser/grammar.y b/parser/grammar.y
@@ -76,6 +76,9 @@ func setCtx(exprs []ast.Expr, ctx ast.ExprContext) {
 	exchandlers	[]*ast.ExceptHandler
 	withitem	*ast.WithItem
 	withitems	[]*ast.WithItem
+	arg		*ast.Arg
+	args		[]*ast.Arg
+	arguments	*ast.Arguments
 }
 
 %type <obj> strings
@@ -91,14 +94,17 @@ func setCtx(exprs []ast.Expr, ctx ast.ExprContext) {
 %type <slice> subscript subscriptlist subscripts
 %type <call> argument arguments optional_arguments arguments2
 %type <level> dot dots
-%type <str> dotted_name from_arg
+%type <str> dotted_name from_arg vfpdef
 %type <identifiers> names
 %type <alias> dotted_as_name import_as_name
 %type <aliases> dotted_as_names import_as_names import_from_arg
 %type <ifstmt> elifs
 %type <exchandlers> except_clauses
 %type <withitem> with_item
 %type <withitems> with_items
+%type <arg> vfpdeftest optional_vfpdef
+%type <args> vfpdeftests vfpdeftests1
+%type <arguments> varargslist
 
 %token NEWLINE
 %token ENDMARKER
@@ -408,69 +414,94 @@ tfpdef:
 vfpdeftest:
 	vfpdef
 	{
-		// FIXME
+		$$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}
+		$<expr>$ = nil
 	}
 |	vfpdef '=' test
 	{
-		// FIXME
+		$$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}
+		$<expr>$ = $3
 	}
 
 vfpdeftests:
 	{
-		// FIXME
+		$$ = nil
+		$<exprs>$ = nil
 	}
 |	vfpdeftests ',' vfpdeftest
 	{
-		// FIXME
+		$$ = append($$, $3)
+		if $<expr>3 != nil {
+			$<exprs>$ = append($<exprs>$, $<expr>3)
+		}
+	}
+
+vfpdeftests1:
+	vfpdeftest
+	{
+		$$ = nil
+		$$ = append($$, $1)
+		$<exprs>$ = nil
+		if $<expr>1 != nil {
+			$<exprs>$ = append($<exprs>$, $<expr>1)
+		}
+	}
+|	vfpdeftests1 ',' vfpdeftest
+	{
+		$$ = append($$, $3)
+		if $<expr>3 != nil {
+			$<exprs>$ = append($<exprs>$, $<expr>3)
+		}
 	}
 
 optional_vfpdef:
 	{
-		// FIXME
+		$$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier("")}
 	}
 |	vfpdef
 	{
-		// FIXME
+		$$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}
 	}
 
+// FIXME this isn't checking all the python rules for args before kwargs etc
 varargslist:
-	vfpdeftest vfpdeftests
+	vfpdeftests1 optional_comma
 	{
-		// FIXME
+		$$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1}
 	}
-|	vfpdeftest vfpdeftests ','
+|	vfpdeftests1 ',' '*' optional_vfpdef vfpdeftests
 	{
-		// FIXME
+		$$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Vararg: $4, Kwonlyargs: $5, KwDefaults: $<exprs>5}
 	}
-|	vfpdeftest vfpdeftests ',' '*' optional_vfpdef vfpdeftests
+|	vfpdeftests1 ',' '*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef
 	{
-		// FIXME
+		starstar := &ast.Arg{Pos: $<pos>8, Arg: ast.Identifier($8)}
+		$$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Vararg: $4, Kwonlyargs: $5, KwDefaults: $<exprs>5, Kwarg: starstar}
 	}
-|	vfpdeftest vfpdeftests ',' '*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef
+|	vfpdeftests1 ',' STARSTAR vfpdef
 	{
-		// FIXME
-	}
-|	vfpdeftest vfpdeftests ',' STARSTAR vfpdef
-	{
-		// FIXME
+		starstar := &ast.Arg{Pos: $<pos>4, Arg: ast.Identifier($4)}
+		$$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Kwarg: starstar}
 	}
 |	'*' optional_vfpdef vfpdeftests
 	{
-		// FIXME
+		$$ = &ast.Arguments{Pos: $<pos>$, Vararg: $2, Kwonlyargs: $3, KwDefaults: $<exprs>3}
 	}
 |	'*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef
 	{
-		// FIXME
+		starstar := &ast.Arg{Pos: $<pos>6, Arg: ast.Identifier($6)}
+		$$ = &ast.Arguments{Pos: $<pos>$, Vararg: $2, Kwonlyargs: $3, KwDefaults: $<exprs>3, Kwarg: starstar}
 	}
 |	STARSTAR vfpdef
 	{
-		// FIXME
+		starstar := &ast.Arg{Pos: $<pos>2, Arg: ast.Identifier($2)}
+		$$ = &ast.Arguments{Pos: $<pos>$, Kwarg: starstar}
 	}
 
 vfpdef:
 	NAME
 	{
-		// FIXME
+		$$ = $1
 	}
 
 stmt:
@@ -1161,21 +1192,24 @@ test_nocond:
 lambdef:
 	LAMBDA ':' test
 	{
-		// FIXME
+		args := &ast.Arguments{Pos: $<pos>$}
+		$$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: args, Body: $3}
 	}
 |	LAMBDA varargslist ':' test
 	{
-		// FIXME
+		$$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: $2, Body: $4}
 	}
 
+// FIXME not sure this is necessary
 lambdef_nocond:
 	LAMBDA ':' test_nocond
 	{
-		// FIXME
+		args := &ast.Arguments{Pos: $<pos>$}
+		$$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: args, Body: $3}
 	}
 |	LAMBDA varargslist ':' test_nocond
 	{
-		// FIXME
+		$$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: $2, Body: $4}
 	}
 
 or_test:
diff --git a/parser/grammar_test.go b/parser/grammar_test.go
@@ -234,6 +234,20 @@ func TestGrammar(t *testing.T) {
 		{"a = b = c", "exec", "Module(body=[Assign(targets=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], value=Name(id='c', ctx=Load()))])"},
 		{"a, b = 1, 2", "exec", "Module(body=[Assign(targets=[Tuple(elts=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store())], value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))])"},
 		{"a, b = c, d = 1, 2", "exec", "Module(body=[Assign(targets=[Tuple(elts=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store()), Tuple(elts=[Name(id='c', ctx=Store()), Name(id='d', ctx=Store())], ctx=Store())], value=Tuple(elts=[Num(n=1), Num(n=2)], ctx=Load()))])"},
+		{"lambda: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda: lambda: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load()))))"},
+		{"lambda a: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, b: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None), arg(arg='b', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, b,: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None), arg(arg='b', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a = b: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Name(id='b', ctx=Load())]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, b=c: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None), arg(arg='b', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Name(id='c', ctx=Load())]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, *b: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=arg(arg='b', annotation=None), kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, *b, c=d: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=arg(arg='b', annotation=None), kwonlyargs=[arg(arg='c', annotation=None)], kw_defaults=[Name(id='d', ctx=Load())], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, *b, c=d, **kws: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=arg(arg='b', annotation=None), kwonlyargs=[arg(arg='c', annotation=None)], kw_defaults=[Name(id='d', ctx=Load())], kwarg=arg(arg='kws', annotation=None), defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda a, c=d, **kws: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None), arg(arg='c', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=arg(arg='kws', annotation=None), defaults=[Name(id='d', ctx=Load())]), body=Name(id='a', ctx=Load())))"},
+		{"lambda *args, c=d: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=arg(arg='args', annotation=None), kwonlyargs=[arg(arg='c', annotation=None)], kw_defaults=[Name(id='d', ctx=Load())], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda *args, c=d, **kws: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=arg(arg='args', annotation=None), kwonlyargs=[arg(arg='c', annotation=None)], kw_defaults=[Name(id='d', ctx=Load())], kwarg=arg(arg='kws', annotation=None), defaults=[]), body=Name(id='a', ctx=Load())))"},
+		{"lambda **kws: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=arg(arg='kws', annotation=None), defaults=[]), body=Name(id='a', ctx=Load())))"},
 		// END TESTS
 	} {
 		Ast, err := ParseString(test.in, test.mode)
diff --git a/parser/make_grammar_test.py b/parser/make_grammar_test.py
@@ -335,6 +335,22 @@
     ("a = b = c", "exec"),
     ("a, b = 1, 2", "exec"),
     ("a, b = c, d = 1, 2", "exec"),
+
+    # lambda
+    ("lambda: a", "eval"),
+    ("lambda: lambda: a", "eval"),
+    ("lambda a: a", "eval"),
+    ("lambda a, b: a", "eval"),
+    ("lambda a, b,: a", "eval"),
+    ("lambda a = b: a", "eval"),
+    ("lambda a, b=c: a", "eval"),
+    ("lambda a, *b: a", "eval"),
+    ("lambda a, *b, c=d: a", "eval"),
+    ("lambda a, *b, c=d, **kws: a", "eval"),
+    ("lambda a, c=d, **kws: a", "eval"),
+    ("lambda *args, c=d: a", "eval"),
+    ("lambda *args, c=d, **kws: a", "eval"),
+    ("lambda **kws: a", "eval"),
 ]
 
 def dump(source, mode):

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,9 @@ func setCtx(exprs []ast.Expr, ctx ast.ExprContext) {`
`76`	`76`	`exchandlers []*ast.ExceptHandler`
`77`	`77`	`withitem *ast.WithItem`
`78`	`78`	`withitems []*ast.WithItem`
	`79`	`+ arg *ast.Arg`
	`80`	`+ args []*ast.Arg`
	`81`	`+ arguments *ast.Arguments`
`79`	`82`	`}`
`80`	`83`
`81`	`84`	`%type <obj> strings`
`@@ -91,14 +94,17 @@ func setCtx(exprs []ast.Expr, ctx ast.ExprContext) {`
`91`	`94`	`%type <slice> subscript subscriptlist subscripts`
`92`	`95`	`%type <call> argument arguments optional_arguments arguments2`
`93`	`96`	`%type <level> dot dots`
`94`		`-%type <str> dotted_name from_arg`
	`97`	`+%type <str> dotted_name from_arg vfpdef`
`95`	`98`	`%type <identifiers> names`
`96`	`99`	`%type <alias> dotted_as_name import_as_name`
`97`	`100`	`%type <aliases> dotted_as_names import_as_names import_from_arg`
`98`	`101`	`%type <ifstmt> elifs`
`99`	`102`	`%type <exchandlers> except_clauses`
`100`	`103`	`%type <withitem> with_item`
`101`	`104`	`%type <withitems> with_items`
	`105`	`+%type <arg> vfpdeftest optional_vfpdef`
	`106`	`+%type <args> vfpdeftests vfpdeftests1`
	`107`	`+%type <arguments> varargslist`
`102`	`108`
`103`	`109`	`%token NEWLINE`
`104`	`110`	`%token ENDMARKER`
`@@ -408,69 +414,94 @@ tfpdef:`
`408`	`414`	`vfpdeftest:`
`409`	`415`	`vfpdef`
`410`	`416`	`{`
`411`		`- // FIXME`
	`417`	`+ $$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}`
	`418`	`+ $<expr>$ = nil`
`412`	`419`	`}`
`413`	`420`	`\| vfpdef '=' test`
`414`	`421`	`{`
`415`		`- // FIXME`
	`422`	`+ $$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}`
	`423`	`+ $<expr>$ = $3`
`416`	`424`	`}`
`417`	`425`
`418`	`426`	`vfpdeftests:`
`419`	`427`	`{`
`420`		`- // FIXME`
	`428`	`+ $$ = nil`
	`429`	`+ $<exprs>$ = nil`
`421`	`430`	`}`
`422`	`431`	`\| vfpdeftests ',' vfpdeftest`
`423`	`432`	`{`
`424`		`- // FIXME`
	`433`	`+ $$ = append($$, $3)`
	`434`	`+ if $<expr>3 != nil {`
	`435`	`+ $<exprs>$ = append($<exprs>$, $<expr>3)`
	`436`	`+ }`
	`437`	`+ }`
	`438`	`+`
	`439`	`+vfpdeftests1:`
	`440`	`+ vfpdeftest`
	`441`	`+ {`
	`442`	`+ $$ = nil`
	`443`	`+ $$ = append($$, $1)`
	`444`	`+ $<exprs>$ = nil`
	`445`	`+ if $<expr>1 != nil {`
	`446`	`+ $<exprs>$ = append($<exprs>$, $<expr>1)`
	`447`	`+ }`
	`448`	`+ }`
	`449`	`+\| vfpdeftests1 ',' vfpdeftest`
	`450`	`+ {`
	`451`	`+ $$ = append($$, $3)`
	`452`	`+ if $<expr>3 != nil {`
	`453`	`+ $<exprs>$ = append($<exprs>$, $<expr>3)`
	`454`	`+ }`
`425`	`455`	`}`
`426`	`456`
`427`	`457`	`optional_vfpdef:`
`428`	`458`	`{`
`429`		`- // FIXME`
	`459`	`+ $$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier("")}`
`430`	`460`	`}`
`431`	`461`	`\| vfpdef`
`432`	`462`	`{`
`433`		`- // FIXME`
	`463`	`+ $$ = &ast.Arg{Pos: $<pos>$, Arg: ast.Identifier($1)}`
`434`	`464`	`}`
`435`	`465`
	`466`	`+// FIXME this isn't checking all the python rules for args before kwargs etc`
`436`	`467`	`varargslist:`
`437`		`- vfpdeftest vfpdeftests`
	`468`	`+ vfpdeftests1 optional_comma`
`438`	`469`	`{`
`439`		`- // FIXME`
	`470`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1}`
`440`	`471`	`}`
`441`		`-\| vfpdeftest vfpdeftests ','`
	`472`	`+\| vfpdeftests1 ',' '*' optional_vfpdef vfpdeftests`
`442`	`473`	`{`
`443`		`- // FIXME`
	`474`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Vararg: $4, Kwonlyargs: $5, KwDefaults: $<exprs>5}`
`444`	`475`	`}`
`445`		`-\| vfpdeftest vfpdeftests ',' '*' optional_vfpdef vfpdeftests`
	`476`	`+\| vfpdeftests1 ',' '*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef`
`446`	`477`	`{`
`447`		`- // FIXME`
	`478`	`+ starstar := &ast.Arg{Pos: $<pos>8, Arg: ast.Identifier($8)}`
	`479`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Vararg: $4, Kwonlyargs: $5, KwDefaults: $<exprs>5, Kwarg: starstar}`
`448`	`480`	`}`
`449`		`-\| vfpdeftest vfpdeftests ',' '*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef`
	`481`	`+\| vfpdeftests1 ',' STARSTAR vfpdef`
`450`	`482`	`{`
`451`		`- // FIXME`
`452`		`- }`
`453`		`-\| vfpdeftest vfpdeftests ',' STARSTAR vfpdef`
`454`		`- {`
`455`		`- // FIXME`
	`483`	`+ starstar := &ast.Arg{Pos: $<pos>4, Arg: ast.Identifier($4)}`
	`484`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Args: $1, Defaults: $<exprs>1, Kwarg: starstar}`
`456`	`485`	`}`
`457`	`486`	`\| '*' optional_vfpdef vfpdeftests`
`458`	`487`	`{`
`459`		`- // FIXME`
	`488`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Vararg: $2, Kwonlyargs: $3, KwDefaults: $<exprs>3}`
`460`	`489`	`}`
`461`	`490`	`\| '*' optional_vfpdef vfpdeftests ',' STARSTAR vfpdef`
`462`	`491`	`{`
`463`		`- // FIXME`
	`492`	`+ starstar := &ast.Arg{Pos: $<pos>6, Arg: ast.Identifier($6)}`
	`493`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Vararg: $2, Kwonlyargs: $3, KwDefaults: $<exprs>3, Kwarg: starstar}`
`464`	`494`	`}`
`465`	`495`	`\| STARSTAR vfpdef`
`466`	`496`	`{`
`467`		`- // FIXME`
	`497`	`+ starstar := &ast.Arg{Pos: $<pos>2, Arg: ast.Identifier($2)}`
	`498`	`+ $$ = &ast.Arguments{Pos: $<pos>$, Kwarg: starstar}`
`468`	`499`	`}`
`469`	`500`
`470`	`501`	`vfpdef:`
`471`	`502`	`NAME`
`472`	`503`	`{`
`473`		`- // FIXME`
	`504`	`+ $$ = $1`
`474`	`505`	`}`
`475`	`506`
`476`	`507`	`stmt:`
`@@ -1161,21 +1192,24 @@ test_nocond:`
`1161`	`1192`	`lambdef:`
`1162`	`1193`	`LAMBDA ':' test`
`1163`	`1194`	`{`
`1164`		`- // FIXME`
	`1195`	`+ args := &ast.Arguments{Pos: $<pos>$}`
	`1196`	`+ $$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: args, Body: $3}`
`1165`	`1197`	`}`
`1166`	`1198`	`\| LAMBDA varargslist ':' test`
`1167`	`1199`	`{`
`1168`		`- // FIXME`
	`1200`	`+ $$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: $2, Body: $4}`
`1169`	`1201`	`}`
`1170`	`1202`
	`1203`	`+// FIXME not sure this is necessary`
`1171`	`1204`	`lambdef_nocond:`
`1172`	`1205`	`LAMBDA ':' test_nocond`
`1173`	`1206`	`{`
`1174`		`- // FIXME`
	`1207`	`+ args := &ast.Arguments{Pos: $<pos>$}`
	`1208`	`+ $$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: args, Body: $3}`
`1175`	`1209`	`}`
`1176`	`1210`	`\| LAMBDA varargslist ':' test_nocond`
`1177`	`1211`	`{`
`1178`		`- // FIXME`
	`1212`	`+ $$ = &ast.Lambda{ExprBase: ast.ExprBase{$<pos>$}, Args: $2, Body: $4}`
`1179`	`1213`	`}`
`1180`	`1214`
`1181`	`1215`	`or_test:`