Skip to content

[New Parser] Fix support for in for Expressions (w/o breaking for_statement) #783

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
certik merged 6 commits into from
Jul 21, 2022
Merged

[New Parser] Fix support for in for Expressions (w/o breaking for_statement) #783

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
5c50a7f
Support precedence not for expr_list
krshrimali Jul 19, 2022
43fc70c
Use separate types for for statements, separate precedences for expre…
krshrimali Jul 19, 2022
1f16485
Merge branch 'fix/new_parser/precedence_not' of github.com:krshrimali…
krshrimali Jul 20, 2022
2beddc5
Merge remote-tracking branch 'upstream/main' into fix/new_parser/prec…
krshrimali Jul 20, 2022
dec01a4
Add tests for statements using comparators
krshrimali Jul 20, 2022
a407135
Add artifacts for added tests
krshrimali Jul 20, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 21 additions & 7 deletions src/lpython/parser/parser.yy
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -178,6 +178,7 @@ void yyerror(YYLTYPE *yyloc, LFortran::Parser &p, const std::string &msg)
%type <ast> id
%type <ast> expr
%type <vec_ast> expr_list
%type <vec_ast> expr_for_list
%type <vec_ast> expr_list_opt
%type <ast> tuple_list
%type <ast> statement
Expand All @@ -199,6 +200,7 @@ void yyerror(YYLTYPE *yyloc, LFortran::Parser &p, const std::string &msg)
%type <ast> assignment_statement
%type <vec_ast> target_list
%type <ast> tuple_item
%type <ast> tuple_for_statement_item
%type <ast> ann_assignment_statement
%type <ast> delete_statement
%type <ast> return_statement
Expand Down Expand Up @@ -367,6 +369,13 @@ tuple_item
| "(" expr_list "," expr ")" { $$ = TUPLE_01(TUPLE_($2, $4), @$); }
;

tuple_for_statement_item
: expr_for_list { $$ = TUPLE_01($1, @$); }
| expr_for_list "," { $$ = TUPLE_03($1, @$); }
| "(" expr_for_list "," ")" { $$ = TUPLE_03($2, @$); }
| "(" expr_for_list "," expr ")" { $$ = TUPLE_01(TUPLE_($2, $4), @$); }
;

target_list
: target_list tuple_item "=" { $$ = $1; LIST_ADD($$, $2); }
| tuple_item "=" { LIST_NEW($$); LIST_ADD($$, $1); }
Expand Down Expand Up @@ -488,13 +497,13 @@ if_statement
;

for_statement
: KW_FOR tuple_item KW_IN expr ":" sep statements {
: KW_FOR tuple_for_statement_item KW_IN expr ":" sep statements {
$$ = FOR_01($2, $4, $7, @$); }
| KW_FOR tuple_item KW_IN expr ":" sep statements KW_ELSE ":"
| KW_FOR tuple_for_statement_item KW_IN expr ":" sep statements KW_ELSE ":"
sep statements { $$ = FOR_02($2, $4, $7, $11, @$); }
| KW_FOR tuple_item KW_IN expr ":" TK_TYPE_COMMENT TK_NEWLINE statements {
| KW_FOR tuple_for_statement_item KW_IN expr ":" TK_TYPE_COMMENT TK_NEWLINE statements {
$$ = FOR_03($2, $4, $6, $8, @$); }
| KW_FOR tuple_item KW_IN expr ":" TK_TYPE_COMMENT TK_NEWLINE statements
| KW_FOR tuple_for_statement_item KW_IN expr ":" TK_TYPE_COMMENT TK_NEWLINE statements
Comment thread
krshrimali marked this conversation as resolved.
KW_ELSE ":" sep statements { $$ = FOR_04($2, $4, $8, $12, $6, @$); }
;

Expand Down Expand Up @@ -633,9 +642,9 @@ async_func_def
;

async_for_stmt
: KW_ASYNC KW_FOR tuple_item KW_IN expr ":" sep statements {
: KW_ASYNC KW_FOR tuple_for_statement_item KW_IN expr ":" sep statements {
$$ = ASYNC_FOR_01($3, $5, $8, @$); }
| KW_ASYNC KW_FOR tuple_item KW_IN expr ":" sep statements KW_ELSE ":" sep
| KW_ASYNC KW_FOR tuple_for_statement_item KW_IN expr ":" sep statements KW_ELSE ":" sep
statements { $$ = ASYNC_FOR_02($3, $5, $8, $12, @$); }
;

Expand Down Expand Up @@ -678,7 +687,12 @@ expr_list_opt
;

expr_list
: expr_list "," expr %prec FOR { $$ = $1; LIST_ADD($$, $3); }
: expr_list "," expr %prec "not" { $$ = $1; LIST_ADD($$, $3); }
| expr %prec "not" { LIST_NEW($$); LIST_ADD($$, $1); }
Comment thread
Thirumalai-Shaktivel marked this conversation as resolved.
;

expr_for_list
: expr_for_list "," expr %prec FOR { $$ = $1; LIST_ADD($$, $3); }
| expr %prec FOR { LIST_NEW($$); LIST_ADD($$, $1); }
;

Expand Down
29 changes: 29 additions & 0 deletions tests/parser/statements1.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -126,3 +126,32 @@
x = 1

a = {1, 2, 3}

# Assigning outputs of expressions to variables

output: bool = x == y
output: bool
output = x == y

output: bool = x > y
output: bool
output = x > y

output: bool = [x] not in [y]
output: bool
output = [x] not in [y]

def comparison_return(a, b):
return a > b

def comparison_return(a, b):
return [a] in [b]

def comparison_return(a, b):
output: bool
output = [a] not in [b]
return output

def comparison_return(a, b):
output = [a] not in [b]
return output
4 changes: 2 additions & 2 deletions tests/reference/ast_new-statements1-e081093.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,11 +2,11 @@
"basename": "ast_new-statements1-e081093",
"cmd": "lpython --show-ast --new-parser --no-color {infile} -o {outfile}",
"infile": "tests/parser/statements1.py",
"infile_hash": "00b7157f02a5a98bdac6ca52297ba0fd1175c648df82c543d0a8d232",
"infile_hash": "8a786ff37449feb98a385df5f952bd91c8f910479ccbb4906e25c060",
"outfile": null,
"outfile_hash": null,
"stdout": "ast_new-statements1-e081093.stdout",
"stdout_hash": "a6635960221bc739fbd0dfb6204cf929f7242dddbfc54eb7254f8943",
"stdout_hash": "0af4b626e5d319f625ee090113d52f0f7d0b5bb508f728b30e3f7096",
"stderr": null,
"stderr_hash": null,
"returncode": 0
Expand Down
2 changes: 1 addition & 1 deletion tests/reference/ast_new-statements1-e081093.stdout
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1 +1 @@
(Module [(Pass) (Break) (Continue) (Raise () ()) (Raise (Call (Name NameError Load) [(ConstantStr "String" ())] []) ()) (Raise (Name RuntimeError Load) (Name exc Load)) (Assert (Compare (Call (Name len Load) [(Name marks Load)] []) NotEq [(ConstantInt 0 ())]) (ConstantStr "List is empty." ())) (Assert (Compare (Name x Load) Eq [(ConstantStr "String" ())]) ()) (Assign [(Name x Store)] (ConstantInt 1 ()) ()) (Assign [(Tuple [(Name x Store) (Name y Store)] Store)] (Call (Name x Load) [] []) ()) (Assign [(Name x Store) (Name y Store)] (ConstantInt 1 ()) ()) (Assign [(Tuple [(Name x Store) (Name y Store)] Store)] (Tuple [(ConstantInt 1 ()) (ConstantInt 2 ())] Load) ()) (Assign [(Subscript (Name x Load) (Name i Load) Store)] (Tuple [(ConstantInt 1 ()) (ConstantInt 2 ())] Load) ()) (Assign [(Tuple [(Name x Store) (Name y Store) (Name z Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store) (Name y Store) (Name z Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store)] Store)] (Name t Load) ()) (AugAssign (Name x Store) Add (ConstantInt 1 ())) (AnnAssign (Name x Store) (Name i64 Load) () 1) (AnnAssign (Name y Store) (Name i32 Load) (ConstantInt 1 ()) 1) (Delete [(Name x Del)]) (Delete [(Tuple [] Del)]) (Delete [(Tuple [(Name x Del) (Name y Del)] Del)]) (Delete [(Tuple [(Name x Del) (Name y Del)] Del)]) (Delete [(Name x Del) (Name y Del)]) (Delete [(Name x Del) (Name y Del)]) (Return ()) (Return (BinOp (Name a Load) Add (Name b Load))) (Return (Call (Name x Load) [(Name a Load)] [])) (Return (Tuple [] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Global [a]) (Global [a b]) (Nonlocal [a]) (Nonlocal [a b]) (Expr (ConstantInt 123 ())) (Expr (UnaryOp USub (ConstantInt 123 ()))) (Expr (UnaryOp USub (ConstantInt 291 ()))) (Expr (ConstantInt 6844 ())) (Expr (UnaryOp USub (ConstantInt 83 ()))) (Expr (ConstantInt 87 ())) (Expr (UnaryOp USub (ConstantInt 13 ()))) (Expr (ConstantInt 13 ())) (Expr (ConstantInt 32768 ())) (Expr (ConstantInt 12 ())) (Expr (ConstantInt 23440334322333 ())) (Expr (ConstantFloat 1.23000000000000000e+02 ())) (Expr (ConstantFloat 1.23450000000000003e+02 ())) (Expr (ConstantFloat 1.23400000000000000e+11 ())) (Expr (BinOp (ConstantInt 12 ()) Add (ConstantComplex 0.00000000000000000e+00 3.00000000000000000e+00 ()))) (Expr (BinOp (ConstantFloat 1.19999999999999996e-01 ()) Add (ConstantComplex 0.00000000000000000e+00 1.00000000000000002e-03 ()))) (Expr (ConstantStr "String" ())) (Expr (ConstantStr "String String" ())) (Expr (ConstantStr "String String" ())) (Expr (ConstantStr "String String" ())) (Expr (Subscript (ConstantStr "String String" ()) (Slice (ConstantInt 1 ()) () ()) Load)) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (BinOp (ConstantStr "String " ()) Add (ConstantStr "String" ())) ()) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (ConstantStr "String " ()) ()) (Expr (ConstantStr "String" ())) (Expr (ConstantBool .true. ())) (Expr (ConstantBool .false. ())) (Expr (BinOp (BinOp (Name x Load) Add (Name y Load)) Mult (Name z Load))) (Expr (BinOp (Name x Load) Sub (Name y Load))) (Expr (BinOp (Name x Load) Mult (Name y Load))) (Expr (BinOp (Name x Load) Div (Name y Load))) (Expr (BinOp (Name x Load) Mod (Name y Load))) (Expr (UnaryOp USub (Name y Load))) (Expr (UnaryOp UAdd (Name y Load))) (Expr (UnaryOp Invert (Name y Load))) (Expr (BinOp (Name x Load) Pow (Name y Load))) (Expr (BinOp (Name x Load) FloorDiv (Name y Load))) (Expr (BinOp (Name x Load) MatMult (Name y Load))) (Expr (BinOp (Name x Load) BitAnd (Name y Load))) (Expr (BinOp (Name x Load) BitOr (Name y Load))) (Expr (BinOp (Name x Load) BitXor (Name y Load))) (Expr (BinOp (Name x Load) LShift (Name y Load))) (Expr (BinOp (Name x Load) RShift (Name y Load))) (Expr (Compare (Name x Load) Eq [(Name y Load)])) (Expr (Compare (Name x Load) NotEq [(Name y Load)])) (Expr (Compare (Name x Load) Lt [(Name y Load)])) (Expr (Compare (Name x Load) LtE [(Name y Load)])) (Expr (Compare (Name x Load) Gt [(Name y Load)])) (Expr (Compare (Name x Load) GtE [(Name y Load)])) (Expr (Compare (ConstantStr "hello" ()) In [(Name x Load)])) (Expr (Compare (ConstantStr "a" ()) In [(Call (Attribute (Name a Load) func Load) [] [])])) (Expr (Compare (ConstantStr "lo" ()) In [(ConstantStr "hello" ())])) (Expr (Subscript (Attribute (Name a Load) b Load) (ConstantInt 1 ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice (ConstantInt 1 ()) () ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice () (UnaryOp USub (ConstantInt 1 ())) ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice (ConstantInt 1 ()) (ConstantInt 2 ()) ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice () () ()) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) (ConstantInt 2 ()) (ConstantInt 3 ())) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) () (ConstantInt 3 ())) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) () ()) Load)) (Assign [(Name x Store)] (NamedExpr (Name y Store) (ConstantInt 0 ())) ()) (If (NamedExpr (Name a Store) (Call (Name ord Load) [(ConstantStr "3" ())] [])) [(Assign [(Name x Store)] (ConstantInt 1 ()) ())] []) (Assign [(Name a Store)] (Set [(ConstantInt 1 ()) (ConstantInt 2 ()) (ConstantInt 3 ())]) ())] [])
(Module [(Pass) (Break) (Continue) (Raise () ()) (Raise (Call (Name NameError Load) [(ConstantStr "String" ())] []) ()) (Raise (Name RuntimeError Load) (Name exc Load)) (Assert (Compare (Call (Name len Load) [(Name marks Load)] []) NotEq [(ConstantInt 0 ())]) (ConstantStr "List is empty." ())) (Assert (Compare (Name x Load) Eq [(ConstantStr "String" ())]) ()) (Assign [(Name x Store)] (ConstantInt 1 ()) ()) (Assign [(Tuple [(Name x Store) (Name y Store)] Store)] (Call (Name x Load) [] []) ()) (Assign [(Name x Store) (Name y Store)] (ConstantInt 1 ()) ()) (Assign [(Tuple [(Name x Store) (Name y Store)] Store)] (Tuple [(ConstantInt 1 ()) (ConstantInt 2 ())] Load) ()) (Assign [(Subscript (Name x Load) (Name i Load) Store)] (Tuple [(ConstantInt 1 ()) (ConstantInt 2 ())] Load) ()) (Assign [(Tuple [(Name x Store) (Name y Store) (Name z Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store) (Name y Store) (Name z Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store)] Store)] (Name t Load) ()) (Assign [(Tuple [(Name x Store)] Store)] (Name t Load) ()) (AugAssign (Name x Store) Add (ConstantInt 1 ())) (AnnAssign (Name x Store) (Name i64 Load) () 1) (AnnAssign (Name y Store) (Name i32 Load) (ConstantInt 1 ()) 1) (Delete [(Name x Del)]) (Delete [(Tuple [] Del)]) (Delete [(Tuple [(Name x Del) (Name y Del)] Del)]) (Delete [(Tuple [(Name x Del) (Name y Del)] Del)]) (Delete [(Name x Del) (Name y Del)]) (Delete [(Name x Del) (Name y Del)]) (Return ()) (Return (BinOp (Name a Load) Add (Name b Load))) (Return (Call (Name x Load) [(Name a Load)] [])) (Return (Tuple [] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Return (Tuple [(Name x Load) (Name y Load)] Load)) (Global [a]) (Global [a b]) (Nonlocal [a]) (Nonlocal [a b]) (Expr (ConstantInt 123 ())) (Expr (UnaryOp USub (ConstantInt 123 ()))) (Expr (UnaryOp USub (ConstantInt 291 ()))) (Expr (ConstantInt 6844 ())) (Expr (UnaryOp USub (ConstantInt 83 ()))) (Expr (ConstantInt 87 ())) (Expr (UnaryOp USub (ConstantInt 13 ()))) (Expr (ConstantInt 13 ())) (Expr (ConstantInt 32768 ())) (Expr (ConstantInt 12 ())) (Expr (ConstantInt 23440334322333 ())) (Expr (ConstantFloat 1.23000000000000000e+02 ())) (Expr (ConstantFloat 1.23450000000000003e+02 ())) (Expr (ConstantFloat 1.23400000000000000e+11 ())) (Expr (BinOp (ConstantInt 12 ()) Add (ConstantComplex 0.00000000000000000e+00 3.00000000000000000e+00 ()))) (Expr (BinOp (ConstantFloat 1.19999999999999996e-01 ()) Add (ConstantComplex 0.00000000000000000e+00 1.00000000000000002e-03 ()))) (Expr (ConstantStr "String" ())) (Expr (ConstantStr "String String" ())) (Expr (ConstantStr "String String" ())) (Expr (ConstantStr "String String" ())) (Expr (Subscript (ConstantStr "String String" ()) (Slice (ConstantInt 1 ()) () ()) Load)) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (BinOp (ConstantStr "String " ()) Add (ConstantStr "String" ())) ()) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (ConstantStr "String String" ()) ()) (Assign [(Name x Store)] (ConstantStr "String " ()) ()) (Expr (ConstantStr "String" ())) (Expr (ConstantBool .true. ())) (Expr (ConstantBool .false. ())) (Expr (BinOp (BinOp (Name x Load) Add (Name y Load)) Mult (Name z Load))) (Expr (BinOp (Name x Load) Sub (Name y Load))) (Expr (BinOp (Name x Load) Mult (Name y Load))) (Expr (BinOp (Name x Load) Div (Name y Load))) (Expr (BinOp (Name x Load) Mod (Name y Load))) (Expr (UnaryOp USub (Name y Load))) (Expr (UnaryOp UAdd (Name y Load))) (Expr (UnaryOp Invert (Name y Load))) (Expr (BinOp (Name x Load) Pow (Name y Load))) (Expr (BinOp (Name x Load) FloorDiv (Name y Load))) (Expr (BinOp (Name x Load) MatMult (Name y Load))) (Expr (BinOp (Name x Load) BitAnd (Name y Load))) (Expr (BinOp (Name x Load) BitOr (Name y Load))) (Expr (BinOp (Name x Load) BitXor (Name y Load))) (Expr (BinOp (Name x Load) LShift (Name y Load))) (Expr (BinOp (Name x Load) RShift (Name y Load))) (Expr (Compare (Name x Load) Eq [(Name y Load)])) (Expr (Compare (Name x Load) NotEq [(Name y Load)])) (Expr (Compare (Name x Load) Lt [(Name y Load)])) (Expr (Compare (Name x Load) LtE [(Name y Load)])) (Expr (Compare (Name x Load) Gt [(Name y Load)])) (Expr (Compare (Name x Load) GtE [(Name y Load)])) (Expr (Compare (ConstantStr "hello" ()) In [(Name x Load)])) (Expr (Compare (ConstantStr "a" ()) In [(Call (Attribute (Name a Load) func Load) [] [])])) (Expr (Compare (ConstantStr "lo" ()) In [(ConstantStr "hello" ())])) (Expr (Subscript (Attribute (Name a Load) b Load) (ConstantInt 1 ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice (ConstantInt 1 ()) () ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice () (UnaryOp USub (ConstantInt 1 ())) ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice (ConstantInt 1 ()) (ConstantInt 2 ()) ()) Load)) (Expr (Subscript (Attribute (Name a Load) b Load) (Slice () () ()) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) (ConstantInt 2 ()) (ConstantInt 3 ())) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) () (ConstantInt 3 ())) Load)) (Expr (Subscript (Attribute (Name y Load) z Load) (Slice (ConstantInt 1 ()) () ()) Load)) (Assign [(Name x Store)] (NamedExpr (Name y Store) (ConstantInt 0 ())) ()) (If (NamedExpr (Name a Store) (Call (Name ord Load) [(ConstantStr "3" ())] [])) [(Assign [(Name x Store)] (ConstantInt 1 ()) ())] []) (Assign [(Name a Store)] (Set [(ConstantInt 1 ()) (ConstantInt 2 ()) (ConstantInt 3 ())]) ()) (AnnAssign (Name output Store) (Name bool Load) (Compare (Name x Load) Eq [(Name y Load)]) 1) (AnnAssign (Name output Store) (Name bool Load) () 1) (Assign [(Name output Store)] (Compare (Name x Load) Eq [(Name y Load)]) ()) (AnnAssign (Name output Store) (Name bool Load) (Compare (Name x Load) Gt [(Name y Load)]) 1) (AnnAssign (Name output Store) (Name bool Load) () 1) (Assign [(Name output Store)] (Compare (Name x Load) Gt [(Name y Load)]) ()) (AnnAssign (Name output Store) (Name bool Load) (Compare (List [(Name x Load)] Load) NotIn [(List [(Name y Load)] Load)]) 1) (AnnAssign (Name output Store) (Name bool Load) () 1) (Assign [(Name output Store)] (Compare (List [(Name x Load)] Load) NotIn [(List [(Name y Load)] Load)]) ()) (FunctionDef comparison_return ([] [(a () ()) (b () ())] [] [] [] [] []) [(Return (Compare (Name a Load) Gt [(Name b Load)]))] [] () ()) (FunctionDef comparison_return ([] [(a () ()) (b () ())] [] [] [] [] []) [(Return (Compare (List [(Name a Load)] Load) In [(List [(Name b Load)] Load)]))] [] () ()) (FunctionDef comparison_return ([] [(a () ()) (b () ())] [] [] [] [] []) [(AnnAssign (Name output Store) (Name bool Load) () 1) (Assign [(Name output Store)] (Compare (List [(Name a Load)] Load) NotIn [(List [(Name b Load)] Load)]) ()) (Return (Name output Load))] [] () ()) (FunctionDef comparison_return ([] [(a () ()) (b () ())] [] [] [] [] []) [(Assign [(Name output Store)] (Compare (List [(Name a Load)] Load) NotIn [(List [(Name b Load)] Load)]) ()) (Return (Name output Load))] [] () ())] [])