Implement For and If

ncw · ncw · commit a27bc28864af · 2014-11-27T22:31:25.000Z
diff --git a/parser/grammar.y b/parser/grammar.y
@@ -64,12 +64,14 @@ func applyTrailers(expr ast.Expr, trailers []ast.Expr) ast.Expr {
 	alias		*ast.Alias
 	aliases		[]*ast.Alias
 	identifiers	[]ast.Identifier
+	ifstmt		*ast.If
+	lastif		*ast.If
 }
 
 %type <obj> strings
 %type <mod> inputs file_input single_input eval_input
-%type <stmts> simple_stmt stmt nl_or_stmt small_stmts stmts
-%type <stmt> compound_stmt small_stmt expr_stmt del_stmt pass_stmt flow_stmt import_stmt global_stmt nonlocal_stmt assert_stmt break_stmt continue_stmt return_stmt raise_stmt yield_stmt import_name import_from
+%type <stmts> simple_stmt stmt nl_or_stmt small_stmts stmts suite optional_else
+%type <stmt> compound_stmt small_stmt expr_stmt del_stmt pass_stmt flow_stmt import_stmt global_stmt nonlocal_stmt assert_stmt break_stmt continue_stmt return_stmt raise_stmt yield_stmt import_name import_from while_stmt if_stmt for_stmt
 %type <op> augassign
 %type <expr> expr_or_star_expr expr star_expr xor_expr and_expr shift_expr arith_expr term factor power trailer atom test_or_star_expr test not_test lambdef test_nocond lambdef_nocond or_test and_test comparison testlist testlist_star_expr yield_expr_or_testlist yield_expr yield_expr_or_testlist_star_expr dictorsetmaker sliceop arglist
 %type <exprs> exprlist testlistraw comp_if comp_iter expr_or_star_exprs test_or_star_exprs tests test_colon_tests trailers
@@ -83,6 +85,7 @@ func applyTrailers(expr ast.Expr, trailers []ast.Expr) ast.Expr {
 %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
 
 %token NEWLINE
 %token ENDMARKER
@@ -932,7 +935,7 @@ compound_stmt:
 	}
 |	while_stmt
 	{
-		// FIXME
+		$$ = $1
 	}
 |	for_stmt
 	{
@@ -961,38 +964,63 @@ compound_stmt:
 
 elifs:
 	{
-		// FIXME
+		$$ = nil
+		$<lastif>$ = nil
 	}
 |	elifs ELIF test ':' suite
 	{
-		// FIXME
+		elifs := $$
+		newif := &ast.If{StmtBase: ast.StmtBase{$<pos>$}, Test: $3, Body: $5}
+		if elifs == nil {
+			$$ = newif
+		} else {
+			$<lastif>$.Orelse = []ast.Stmt{newif}
+		}
+		$<lastif>$ = newif
 	}
 
 optional_else:
 	{
-		// FIXME
+		$$ = nil
 	}
 |	ELSE ':' suite
 	{
-		// FIXME
+		$$ = $3
 	}
 
 if_stmt:
 	IF test ':' suite elifs optional_else
 	{
-		// FIXME
+		newif := &ast.If{StmtBase: ast.StmtBase{$<pos>$}, Test: $2, Body: $4}
+		$$ = newif
+		elifs := $5
+		optional_else := $6
+		if len(optional_else) != 0 {
+			if elifs != nil {
+				$<lastif>5.Orelse = optional_else
+				newif.Orelse = []ast.Stmt{elifs}
+			} else {
+				newif.Orelse = optional_else
+			}
+		} else {
+			if elifs != nil {
+				newif.Orelse = []ast.Stmt{elifs}
+			}
+		}
 	}
 
 while_stmt:
 	WHILE test ':' suite optional_else
 	{
-		// FIXME
+		$$ = &ast.While{StmtBase: ast.StmtBase{$<pos>$}, Test: $2, Body: $4, Orelse: $5}
 	}
 
 for_stmt:
 	FOR exprlist IN testlist ':' suite optional_else
 	{
-		// FIXME
+		target := tupleOrExpr($<pos>$, $2, false)
+		target.(ast.SetCtxer).SetCtx(ast.Store)
+		$$ = &ast.For{StmtBase: ast.StmtBase{$<pos>$}, Target: target, Iter: $4, Body: $6, Orelse: $7}
 	}
 
 except_clauses:
@@ -1076,9 +1104,12 @@ stmts:
 
 suite:
 	simple_stmt
+	{
+		$$ = $1
+	}
 |	NEWLINE INDENT stmts DEDENT
 	{
-		// stmts
+		$$ = $3
 	}
 
 test:
diff --git a/parser/grammar_test.go b/parser/grammar_test.go
@@ -196,6 +196,18 @@ func TestGrammar(t *testing.T) {
 		{"assert True", "exec", "Module(body=[Assert(test=NameConstant(value=True), msg=None)])"},
 		{"assert True, 'Bang'", "exec", "Module(body=[Assert(test=NameConstant(value=True), msg=Str(s='Bang'))])"},
 		{"assert a == b, 'Bang'", "exec", "Module(body=[Assert(test=Compare(left=Name(id='a', ctx=Load()), ops=[Eq()], comparators=[Name(id='b', ctx=Load())]), msg=Str(s='Bang'))])"},
+		{"while True: pass", "exec", "Module(body=[While(test=NameConstant(value=True), body=[Pass()], orelse=[])])"},
+		{"while True:\n pass\n", "exec", "Module(body=[While(test=NameConstant(value=True), body=[Pass()], orelse=[])])"},
+		{"while True:\n pass\nelse:\n return\n", "exec", "Module(body=[While(test=NameConstant(value=True), body=[Pass()], orelse=[Return(value=None)])])"},
+		{"if True: pass", "exec", "Module(body=[If(test=NameConstant(value=True), body=[Pass()], orelse=[])])"},
+		{"if True:\n pass\n", "exec", "Module(body=[If(test=NameConstant(value=True), body=[Pass()], orelse=[])])"},
+		{"if True:\n    pass\n    continue\nelse:\n    break\n    pass\n", "exec", "Module(body=[If(test=NameConstant(value=True), body=[Pass(), Continue()], orelse=[Break(), Pass()])])"},
+		{"if a:\n    continue\nelif b:\n    break\nelif c:\n    pass\nelif c:\n    continue\n    pass\n", "exec", "Module(body=[If(test=Name(id='a', ctx=Load()), body=[Continue()], orelse=[If(test=Name(id='b', ctx=Load()), body=[Break()], orelse=[If(test=Name(id='c', ctx=Load()), body=[Pass()], orelse=[If(test=Name(id='c', ctx=Load()), body=[Continue(), Pass()], orelse=[])])])])])"},
+		{"if a:\n    continue\nelif b:\n    break\nelse:\n    continue\n    pass\n", "exec", "Module(body=[If(test=Name(id='a', ctx=Load()), body=[Continue()], orelse=[If(test=Name(id='b', ctx=Load()), body=[Break()], orelse=[Continue(), Pass()])])])"},
+		{"if a:\n    continue\nelif b:\n    break\nelif c:\n    pass\nelse:\n    continue\n    pass\n", "exec", "Module(body=[If(test=Name(id='a', ctx=Load()), body=[Continue()], orelse=[If(test=Name(id='b', ctx=Load()), body=[Break()], orelse=[If(test=Name(id='c', ctx=Load()), body=[Pass()], orelse=[Continue(), Pass()])])])])"},
+		{"for a in b: pass", "exec", "Module(body=[For(target=Name(id='a', ctx=Store()), iter=Name(id='b', ctx=Load()), body=[Pass()], orelse=[])])"},
+		{"for a, b in b: pass", "exec", "Module(body=[For(target=Tuple(elts=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store()), iter=Name(id='b', ctx=Load()), body=[Pass()], orelse=[])])"},
+		{"for a, b in b:\n pass\nelse: break\n", "exec", "Module(body=[For(target=Tuple(elts=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store()), iter=Name(id='b', ctx=Load()), body=[Pass()], orelse=[Break()])])"},
 		// END TESTS
 	} {
 		Ast, err := ParseString(test.in, test.mode)
diff --git a/parser/make_grammar_test.py b/parser/make_grammar_test.py
@@ -203,6 +203,55 @@
     ("assert True", "exec"),
     ("assert True, 'Bang'", "exec"),
     ("assert a == b, 'Bang'", "exec"),
+
+    # Compound statements
+    ("while True: pass", "exec"),
+    ("while True:\n pass\n", "exec"),
+    ("while True:\n pass\nelse:\n return\n", "exec"),
+    ("if True: pass", "exec"),
+    ("if True:\n pass\n", "exec"),
+    ("""\
+if True:
+    pass
+    continue
+else:
+    break
+    pass
+""", "exec"),
+    ("""\
+if a:
+    continue
+elif b:
+    break
+elif c:
+    pass
+elif c:
+    continue
+    pass
+""", "exec"),
+    ("""\
+if a:
+    continue
+elif b:
+    break
+else:
+    continue
+    pass
+""", "exec"),
+    ("""\
+if a:
+    continue
+elif b:
+    break
+elif c:
+    pass
+else:
+    continue
+    pass
+""", "exec"),
+    ("for a in b: pass", "exec"),
+    ("for a, b in b: pass", "exec"),
+    ("for a, b in b:\n pass\nelse: break\n", "exec"),
 ]
 
 def dump(source, mode):

Original file line number	Diff line number	Diff line change
`@@ -64,12 +64,14 @@ func applyTrailers(expr ast.Expr, trailers []ast.Expr) ast.Expr {`
`64`	`64`	`alias *ast.Alias`
`65`	`65`	`aliases []*ast.Alias`
`66`	`66`	`identifiers []ast.Identifier`
	`67`	`+ ifstmt *ast.If`
	`68`	`+ lastif *ast.If`
`67`	`69`	`}`
`68`	`70`
`69`	`71`	`%type <obj> strings`
`70`	`72`	`%type <mod> inputs file_input single_input eval_input`
`71`		`-%type <stmts> simple_stmt stmt nl_or_stmt small_stmts stmts`
`72`		`-%type <stmt> compound_stmt small_stmt expr_stmt del_stmt pass_stmt flow_stmt import_stmt global_stmt nonlocal_stmt assert_stmt break_stmt continue_stmt return_stmt raise_stmt yield_stmt import_name import_from`
	`73`	`+%type <stmts> simple_stmt stmt nl_or_stmt small_stmts stmts suite optional_else`
	`74`	`+%type <stmt> compound_stmt small_stmt expr_stmt del_stmt pass_stmt flow_stmt import_stmt global_stmt nonlocal_stmt assert_stmt break_stmt continue_stmt return_stmt raise_stmt yield_stmt import_name import_from while_stmt if_stmt for_stmt`
`73`	`75`	`%type <op> augassign`
`74`	`76`	`%type <expr> expr_or_star_expr expr star_expr xor_expr and_expr shift_expr arith_expr term factor power trailer atom test_or_star_expr test not_test lambdef test_nocond lambdef_nocond or_test and_test comparison testlist testlist_star_expr yield_expr_or_testlist yield_expr yield_expr_or_testlist_star_expr dictorsetmaker sliceop arglist`
`75`	`77`	`%type <exprs> exprlist testlistraw comp_if comp_iter expr_or_star_exprs test_or_star_exprs tests test_colon_tests trailers`
`@@ -83,6 +85,7 @@ func applyTrailers(expr ast.Expr, trailers []ast.Expr) ast.Expr {`
`83`	`85`	`%type <identifiers> names`
`84`	`86`	`%type <alias> dotted_as_name import_as_name`
`85`	`87`	`%type <aliases> dotted_as_names import_as_names import_from_arg`
	`88`	`+%type <ifstmt> elifs`
`86`	`89`
`87`	`90`	`%token NEWLINE`
`88`	`91`	`%token ENDMARKER`
`@@ -932,7 +935,7 @@ compound_stmt:`
`932`	`935`	`}`
`933`	`936`	`\| while_stmt`
`934`	`937`	`{`
`935`		`- // FIXME`
	`938`	`+ $$ = $1`
`936`	`939`	`}`
`937`	`940`	`\| for_stmt`
`938`	`941`	`{`
`@@ -961,38 +964,63 @@ compound_stmt:`
`961`	`964`
`962`	`965`	`elifs:`
`963`	`966`	`{`
`964`		`- // FIXME`
	`967`	`+ $$ = nil`
	`968`	`+ $<lastif>$ = nil`
`965`	`969`	`}`
`966`	`970`	`\| elifs ELIF test ':' suite`
`967`	`971`	`{`
`968`		`- // FIXME`
	`972`	`+ elifs := $$`
	`973`	`+ newif := &ast.If{StmtBase: ast.StmtBase{$<pos>$}, Test: $3, Body: $5}`
	`974`	`+ if elifs == nil {`
	`975`	`+ $$ = newif`
	`976`	`+ } else {`
	`977`	`+ $<lastif>$.Orelse = []ast.Stmt{newif}`
	`978`	`+ }`
	`979`	`+ $<lastif>$ = newif`
`969`	`980`	`}`
`970`	`981`
`971`	`982`	`optional_else:`
`972`	`983`	`{`
`973`		`- // FIXME`
	`984`	`+ $$ = nil`
`974`	`985`	`}`
`975`	`986`	`\| ELSE ':' suite`
`976`	`987`	`{`
`977`		`- // FIXME`
	`988`	`+ $$ = $3`
`978`	`989`	`}`
`979`	`990`
`980`	`991`	`if_stmt:`
`981`	`992`	`IF test ':' suite elifs optional_else`
`982`	`993`	`{`
`983`		`- // FIXME`
	`994`	`+ newif := &ast.If{StmtBase: ast.StmtBase{$<pos>$}, Test: $2, Body: $4}`
	`995`	`+ $$ = newif`
	`996`	`+ elifs := $5`
	`997`	`+ optional_else := $6`
	`998`	`+ if len(optional_else) != 0 {`
	`999`	`+ if elifs != nil {`
	`1000`	`+ $<lastif>5.Orelse = optional_else`
	`1001`	`+ newif.Orelse = []ast.Stmt{elifs}`
	`1002`	`+ } else {`
	`1003`	`+ newif.Orelse = optional_else`
	`1004`	`+ }`
	`1005`	`+ } else {`
	`1006`	`+ if elifs != nil {`
	`1007`	`+ newif.Orelse = []ast.Stmt{elifs}`
	`1008`	`+ }`
	`1009`	`+ }`
`984`	`1010`	`}`
`985`	`1011`
`986`	`1012`	`while_stmt:`
`987`	`1013`	`WHILE test ':' suite optional_else`
`988`	`1014`	`{`
`989`		`- // FIXME`
	`1015`	`+ $$ = &ast.While{StmtBase: ast.StmtBase{$<pos>$}, Test: $2, Body: $4, Orelse: $5}`
`990`	`1016`	`}`
`991`	`1017`
`992`	`1018`	`for_stmt:`
`993`	`1019`	`FOR exprlist IN testlist ':' suite optional_else`
`994`	`1020`	`{`
`995`		`- // FIXME`
	`1021`	`+ target := tupleOrExpr($<pos>$, $2, false)`
	`1022`	`+ target.(ast.SetCtxer).SetCtx(ast.Store)`
	`1023`	`+ $$ = &ast.For{StmtBase: ast.StmtBase{$<pos>$}, Target: target, Iter: $4, Body: $6, Orelse: $7}`
`996`	`1024`	`}`
`997`	`1025`
`998`	`1026`	`except_clauses:`
`@@ -1076,9 +1104,12 @@ stmts:`
`1076`	`1104`
`1077`	`1105`	`suite:`
`1078`	`1106`	`simple_stmt`
	`1107`	`+ {`
	`1108`	`+ $$ = $1`
	`1109`	`+ }`
`1079`	`1110`	`\| NEWLINE INDENT stmts DEDENT`
`1080`	`1111`	`{`
`1081`		`- // stmts`
	`1112`	`+ $$ = $3`
`1082`	`1113`	`}`
`1083`	`1114`
`1084`	`1115`	`test:`