bill
/
ChocoPy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merged in PA1

Browse Source
master
Sanjar Ahmadov 4 years ago
parent ae3ef07c97 a11ef7f7d9
commit 9bbe3956bc
187 changed files with 10820 additions and 0 deletions
Show Stats Download Patch File Download Diff File

3
build.sh
Unescape View File

@ -0,0 +1,3 @@
#!/bin/bash
mvn clean package -e

3
full_test.sh
Unescape View File

@ -0,0 +1,3 @@
#!/bin/bash
./build.sh
./test.sh

41
grade.md
Unescape View File

@ -0,0 +1,41 @@
# Grading
Core Tests: 66/66
Extra:
- graph.py 5/5
- mergesort.py 5/5
- nesting.py 4/4
=========================
Standard tests: 80/80
Work Log: 10/10
Additional Tests: 10/10
Code style: 10/10
Improvements: +3
Overall: 113/110
# Parsing
Your parser passed all tests, including the hidden ones, congratulations! Nice catch on the multiline string, which is a missing piece in the ChocoPy specification. Looking forward to your next project.
# Testing
Good work in the challenging cases in `good.py` like nested functions and class methods, and in `bad.py` like statements in class definition.
It looks like you haven't added your own tests besides those in `good.py` and `bad.py`. We recommend pinning down more of your functionality with short, targeted tests in the future.
# Process
We generally recommend using pull requests over directly pushing into the master branch, especially when you want to work in parallel. As the project becomes more complex, you may appreciate the benefits of a more structured SDLC process.
# Code
Your code is clean and readable, with consistent naming convention and proper amount of comments. Well done.

24
pa1-tests/README.md
Unescape View File

@ -0,0 +1,24 @@
# Tests for PA1: ChocoPy Parser
Clone a student repository:
```
TEAM="team"
git clone --branch=pa1final \
https://github.com/nyu-compiler-construction/pa1-chocopy-parser-${TEAM}
```
Build it:
```
cd pa1-chocopy-parser-${TEAM}
mvn clean package
```
Clone the tests _into_ the student repository:
```
git clone https://github.com/nyu-compiler-construction/pa1-tests
```
Run the tests:
```
./pa1-tests/run-tests.sh
```

BIN
pa1-tests/chocopy-ref.jar
View File

Binary file not shown.

1
pa1-tests/core/bad_assign_expr1.py
Unescape View File

@ -0,0 +1 @@
x = (y = 2)

16
pa1-tests/core/bad_assign_expr1.py.ast
Unescape View File

@ -0,0 +1,16 @@
{
"kind" : "Program",
"location" : [ 1, 6, 1, 6 ],
"declarations" : [ ],
"statements" : [ ],
"errors" : {
"errors" : [ {
"kind" : "CompilerError",
"location" : [ 1, 8, 1, 8 ],
"message" : "Parse error near token EQ: =",
"syntax" : true
} ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/bad_assign_expr2.py
Unescape View File

@ -0,0 +1 @@
print(x = 1)

16
pa1-tests/core/bad_assign_expr2.py.ast
Unescape View File

@ -0,0 +1,16 @@
{
"kind" : "Program",
"location" : [ 1, 7, 1, 7 ],
"declarations" : [ ],
"statements" : [ ],
"errors" : {
"errors" : [ {
"kind" : "CompilerError",
"location" : [ 1, 9, 1, 9 ],
"message" : "Parse error near token EQ: =",
"syntax" : true
} ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

6
pa1-tests/core/bad_func_def.py
Unescape View File

@ -0,0 +1,6 @@
def foo(a, b) -> 1:
x:int = a
return 1
print(1)
print(3**6)

64
pa1-tests/core/bad_func_def.py.ast
Unescape View File

@ -0,0 +1,64 @@
{
"kind" : "Program",
"location" : [ 2, 13, 6, 8 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 2, 13, 2, 13 ],
"expr" : {
"kind" : "Identifier",
"location" : [ 2, 13, 2, 13 ],
"name" : "a"
}
}, {
"kind" : "ReturnStmt",
"location" : [ 3, 5, 3, 12 ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 12, 3, 12 ],
"value" : 1
}
}, {
"kind" : "ExprStmt",
"location" : [ 5, 1, 5, 8 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 5, 1, 5, 8 ],
"function" : {
"kind" : "Identifier",
"location" : [ 5, 1, 5, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 5, 7, 5, 7 ],
"value" : 1
} ]
}
} ],
"errors" : {
"errors" : [ {
"kind" : "CompilerError",
"location" : [ 1, 10, 1, 10 ],
"message" : "Parse error near token COMMA: ,",
"syntax" : true
}, {
"kind" : "CompilerError",
"location" : [ 2, 13, 2, 13 ],
"message" : "Parse error near token IDENTIFIER: a",
"syntax" : true
}, {
"kind" : "CompilerError",
"location" : [ 5, 1, 5, 0 ],
"message" : "Parse error near token DEDENT: ",
"syntax" : true
}, {
"kind" : "CompilerError",
"location" : [ 6, 9, 6, 9 ],
"message" : "Parse error near token TIMES: *",
"syntax" : true
} ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

3
pa1-tests/core/bad_indentation.py
Unescape View File

@ -0,0 +1,3 @@
x = 1
y = 2
z = 3

47
pa1-tests/core/bad_indentation.py.ast
Unescape View File

@ -0,0 +1,47 @@
{
"kind" : "Program",
"location" : [ 2, 3, 3, 6 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 2, 3, 2, 7 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 2, 3, 2, 3 ],
"name" : "y"
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 7, 2, 7 ],
"value" : 2
}
}, {
"kind" : "AssignStmt",
"location" : [ 3, 1, 3, 5 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 3, 1, 3, 1 ],
"name" : "z"
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 5, 3, 5 ],
"value" : 3
}
} ],
"errors" : {
"errors" : [ {
"kind" : "CompilerError",
"location" : [ 2, 1, 2, 2 ],
"message" : "Parse error near token INDENT: ",
"syntax" : true
}, {
"kind" : "CompilerError",
"location" : [ 3, 1, 3, 0 ],
"message" : "Parse error near token DEDENT: ",
"syntax" : true
} ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/bad_stmt.py
Unescape View File

@ -0,0 +1,4 @@
1 + 2
3 == 4 or (not False && True)
5 + 6
7 << 8

65
pa1-tests/core/bad_stmt.py.ast
Unescape View File

@ -0,0 +1,65 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 7 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 5 ],
"expr" : {
"kind" : "BinaryExpr",
"location" : [ 1, 1, 1, 5 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 1, 1, 1 ],
"value" : 1
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 5, 1, 5 ],
"value" : 2
}
}
}, {
"kind" : "ExprStmt",
"location" : [ 3, 1, 3, 5 ],
"expr" : {
"kind" : "BinaryExpr",
"location" : [ 3, 1, 3, 5 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 1, 3, 1 ],
"value" : 5
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 5, 3, 5 ],
"value" : 6
}
}
}, {
"kind" : "ExprStmt",
"location" : [ 4, 6, 4, 6 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 4, 6, 4, 6 ],
"value" : 8
}
} ],
"errors" : {
"errors" : [ {
"kind" : "CompilerError",
"location" : [ 2, 22, 2, 22 ],
"message" : "Parse error near token UNRECOGNIZED: &",
"syntax" : true
}, {
"kind" : "CompilerError",
"location" : [ 4, 4, 4, 4 ],
"message" : "Parse error near token LT: <",
"syntax" : true
} ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

2
pa1-tests/core/chained_mixed_assignments.py
Unescape View File

@ -0,0 +1,2 @@
x[0] = y = z.f = 1
z.g = y = x[0]

85
pa1-tests/core/chained_mixed_assignments.py.ast
Unescape View File

@ -0,0 +1,85 @@
{
"kind" : "Program",
"location" : [ 1, 1, 2, 15 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 1, 1, 1, 18 ],
"targets" : [ {
"kind" : "IndexExpr",
"location" : [ 1, 1, 1, 4 ],
"list" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "x"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 3, 1, 3 ],
"value" : 0
}
}, {
"kind" : "Identifier",
"location" : [ 1, 8, 1, 8 ],
"name" : "y"
}, {
"kind" : "MemberExpr",
"location" : [ 1, 12, 1, 14 ],
"object" : {
"kind" : "Identifier",
"location" : [ 1, 12, 1, 12 ],
"name" : "z"
},
"member" : {
"kind" : "Identifier",
"location" : [ 1, 14, 1, 14 ],
"name" : "f"
}
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 18, 1, 18 ],
"value" : 1
}
}, {
"kind" : "AssignStmt",
"location" : [ 2, 1, 2, 14 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 2, 1, 2, 3 ],
"object" : {
"kind" : "Identifier",
"location" : [ 2, 1, 2, 1 ],
"name" : "z"
},
"member" : {
"kind" : "Identifier",
"location" : [ 2, 3, 2, 3 ],
"name" : "g"
}
}, {
"kind" : "Identifier",
"location" : [ 2, 7, 2, 7 ],
"name" : "y"
} ],
"value" : {
"kind" : "IndexExpr",
"location" : [ 2, 11, 2, 14 ],
"list" : {
"kind" : "Identifier",
"location" : [ 2, 11, 2, 11 ],
"name" : "x"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 0
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/chained_var_assignments.py
Unescape View File

@ -0,0 +1 @@
x = y = z = 1

32
pa1-tests/core/chained_var_assignments.py.ast
Unescape View File

@ -0,0 +1,32 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 14 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 1, 1, 1, 13 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "x"
}, {
"kind" : "Identifier",
"location" : [ 1, 5, 1, 5 ],
"name" : "y"
}, {
"kind" : "Identifier",
"location" : [ 1, 9, 1, 9 ],
"name" : "z"
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 13, 1, 13 ],
"value" : 1
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/class_attr.py
Unescape View File

@ -0,0 +1,4 @@
class Foo(object):
x:int = 1
f = Foo()

65
pa1-tests/core/class_attr.py.ast
Unescape View File

@ -0,0 +1,65 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 10 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 2, 14 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 9 ],
"name" : "Foo"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 11, 1, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 7, 2, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 1
}
} ]
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 4, 1, 4, 9 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 1 ],
"name" : "f"
} ],
"value" : {
"kind" : "CallExpr",
"location" : [ 4, 5, 4, 9 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 7 ],
"name" : "Foo"
},
"args" : [ ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

5
pa1-tests/core/class_attr_get.py
Unescape View File

@ -0,0 +1,5 @@
class Foo(object):
x:int = 1
f = Foo()
print(f.x)

91
pa1-tests/core/class_attr_get.py.ast
Unescape View File

@ -0,0 +1,91 @@
{
"kind" : "Program",
"location" : [ 1, 1, 5, 11 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 2, 14 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 9 ],
"name" : "Foo"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 11, 1, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 7, 2, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 1
}
} ]
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 4, 1, 4, 9 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 1 ],
"name" : "f"
} ],
"value" : {
"kind" : "CallExpr",
"location" : [ 4, 5, 4, 9 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 7 ],
"name" : "Foo"
},
"args" : [ ]
}
}, {
"kind" : "ExprStmt",
"location" : [ 5, 1, 5, 10 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 5, 1, 5, 10 ],
"function" : {
"kind" : "Identifier",
"location" : [ 5, 1, 5, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "MemberExpr",
"location" : [ 5, 7, 5, 9 ],
"object" : {
"kind" : "Identifier",
"location" : [ 5, 7, 5, 7 ],
"name" : "f"
},
"member" : {
"kind" : "Identifier",
"location" : [ 5, 9, 5, 9 ],
"name" : "x"
}
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

5
pa1-tests/core/class_attr_set.py
Unescape View File

@ -0,0 +1,5 @@
class Foo(object):
x:int = 1
f = Foo()
f.x = 2

87
pa1-tests/core/class_attr_set.py.ast
Unescape View File

@ -0,0 +1,87 @@
{
"kind" : "Program",
"location" : [ 1, 1, 5, 8 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 2, 14 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 9 ],
"name" : "Foo"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 11, 1, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 7, 2, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 1
}
} ]
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 4, 1, 4, 9 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 1 ],
"name" : "f"
} ],
"value" : {
"kind" : "CallExpr",
"location" : [ 4, 5, 4, 9 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 7 ],
"name" : "Foo"
},
"args" : [ ]
}
}, {
"kind" : "AssignStmt",
"location" : [ 5, 1, 5, 7 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 5, 1, 5, 3 ],
"object" : {
"kind" : "Identifier",
"location" : [ 5, 1, 5, 1 ],
"name" : "f"
},
"member" : {
"kind" : "Identifier",
"location" : [ 5, 3, 5, 3 ],
"name" : "x"
}
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 5, 7, 5, 7 ],
"value" : 2
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

8
pa1-tests/core/class_constructor.py
Unescape View File

@ -0,0 +1,8 @@
class Foo(object):
x:int = 0
def __init__(self:"Foo", x:int):
self.x = x
f = Foo(1)
print(f.x)

159
pa1-tests/core/class_constructor.py.ast
Unescape View File

@ -0,0 +1,159 @@
{
"kind" : "Program",
"location" : [ 1, 1, 8, 11 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 7, 0 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 9 ],
"name" : "Foo"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 11, 1, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 7, 2, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 0
}
}, {
"kind" : "FuncDef",
"location" : [ 4, 5, 5, 19 ],
"name" : {
"kind" : "Identifier",
"location" : [ 4, 9, 4, 16 ],
"name" : "__init__"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 4, 18, 4, 27 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 18, 4, 21 ],
"name" : "self"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 23, 4, 27 ],
"className" : "Foo"
}
}, {
"kind" : "TypedVar",
"location" : [ 4, 30, 4, 34 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 30, 4, 30 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 32, 4, 34 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 4, 36, 4, 36 ],
"className" : "<None>"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 5, 9, 5, 18 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 5, 9, 5, 14 ],
"object" : {
"kind" : "Identifier",
"location" : [ 5, 9, 5, 12 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 5, 14, 5, 14 ],
"name" : "x"
}
} ],
"value" : {
"kind" : "Identifier",
"location" : [ 5, 18, 5, 18 ],
"name" : "x"
}
} ]
} ]
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 7, 1, 7, 10 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 7, 1, 7, 1 ],
"name" : "f"
} ],
"value" : {
"kind" : "CallExpr",
"location" : [ 7, 5, 7, 10 ],
"function" : {
"kind" : "Identifier",
"location" : [ 7, 5, 7, 7 ],
"name" : "Foo"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 7, 9, 7, 9 ],
"value" : 1
} ]
}
}, {
"kind" : "ExprStmt",
"location" : [ 8, 1, 8, 10 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 8, 1, 8, 10 ],
"function" : {
"kind" : "Identifier",
"location" : [ 8, 1, 8, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "MemberExpr",
"location" : [ 8, 7, 8, 9 ],
"object" : {
"kind" : "Identifier",
"location" : [ 8, 7, 8, 7 ],
"name" : "f"
},
"member" : {
"kind" : "Identifier",
"location" : [ 8, 9, 8, 9 ],
"name" : "x"
}
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

9
pa1-tests/core/class_method.py
Unescape View File

@ -0,0 +1,9 @@
class Foo(object):
x:int = 0
def set(self:"Foo", x:int) -> object:
self.x = x
f = Foo()
f.set(1)
print(f.x)

181
pa1-tests/core/class_method.py.ast
Unescape View File

@ -0,0 +1,181 @@
{
"kind" : "Program",
"location" : [ 1, 1, 9, 11 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 7, 0 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 9 ],
"name" : "Foo"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 11, 1, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 7, 2, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 13, 2, 13 ],
"value" : 0
}
}, {
"kind" : "FuncDef",
"location" : [ 4, 5, 5, 19 ],
"name" : {
"kind" : "Identifier",
"location" : [ 4, 9, 4, 11 ],
"name" : "set"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 4, 13, 4, 22 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 13, 4, 16 ],
"name" : "self"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 18, 4, 22 ],
"className" : "Foo"
}
}, {
"kind" : "TypedVar",
"location" : [ 4, 25, 4, 29 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 25, 4, 25 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 27, 4, 29 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 4, 35, 4, 40 ],
"className" : "object"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 5, 9, 5, 18 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 5, 9, 5, 14 ],
"object" : {
"kind" : "Identifier",
"location" : [ 5, 9, 5, 12 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 5, 14, 5, 14 ],
"name" : "x"
}
} ],
"value" : {
"kind" : "Identifier",
"location" : [ 5, 18, 5, 18 ],
"name" : "x"
}
} ]
} ]
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 7, 1, 7, 9 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 7, 1, 7, 1 ],
"name" : "f"
} ],
"value" : {
"kind" : "CallExpr",
"location" : [ 7, 5, 7, 9 ],
"function" : {
"kind" : "Identifier",
"location" : [ 7, 5, 7, 7 ],
"name" : "Foo"
},
"args" : [ ]
}
}, {
"kind" : "ExprStmt",
"location" : [ 8, 1, 8, 8 ],
"expr" : {
"kind" : "MethodCallExpr",
"location" : [ 8, 1, 8, 8 ],
"method" : {
"kind" : "MemberExpr",
"location" : [ 8, 1, 8, 5 ],
"object" : {
"kind" : "Identifier",
"location" : [ 8, 1, 8, 1 ],
"name" : "f"
},
"member" : {
"kind" : "Identifier",
"location" : [ 8, 3, 8, 5 ],
"name" : "set"
}
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 8, 7, 8, 7 ],
"value" : 1
} ]
}
}, {
"kind" : "ExprStmt",
"location" : [ 9, 1, 9, 10 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 9, 1, 9, 10 ],
"function" : {
"kind" : "Identifier",
"location" : [ 9, 1, 9, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "MemberExpr",
"location" : [ 9, 7, 9, 9 ],
"object" : {
"kind" : "Identifier",
"location" : [ 9, 7, 9, 7 ],
"name" : "f"
},
"member" : {
"kind" : "Identifier",
"location" : [ 9, 9, 9, 9 ],
"name" : "x"
}
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

38
pa1-tests/core/coverage.py
Unescape View File

@ -0,0 +1,38 @@
count:int = 0
def foo(s: str) -> int:
return len(s)
class bar(object):
p: bool = True
def baz(self:"bar", xx: [int]) -> str:
global count
x:int = 0
y:int = 1
def qux(y: int) -> object:
nonlocal x
if x > y:
x = -1
for x in xx:
self.p = x == 2
qux(0) # Yay! ChocoPy
count = count + 1
while x <= 0:
if self.p:
xx[0] = xx[1]
self.p = not self.p
x = x + 1
elif foo("Long"[0]) == 1:
return self is None
return "Nope"
print(bar().baz([1,2]))

613
pa1-tests/core/coverage.py.ast
Unescape View File

@ -0,0 +1,613 @@
{
"kind" : "Program",
"location" : [ 1, 1, 36, 24 ],
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 1, 1, 1, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 1, 1, 1, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 5 ],
"name" : "count"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 7, 1, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 13, 1, 13 ],
"value" : 0
}
}, {
"kind" : "FuncDef",
"location" : [ 3, 1, 4, 18 ],
"name" : {
"kind" : "Identifier",
"location" : [ 3, 5, 3, 7 ],
"name" : "foo"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 3, 9, 3, 14 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 3, 9, 3, 9 ],
"name" : "s"
},
"type" : {
"kind" : "ClassType",
"location" : [ 3, 12, 3, 14 ],
"className" : "str"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 3, 20, 3, 22 ],
"className" : "int"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 4, 5, 4, 17 ],
"value" : {
"kind" : "CallExpr",
"location" : [ 4, 12, 4, 17 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 12, 4, 14 ],
"name" : "len"
},
"args" : [ {
"kind" : "Identifier",
"location" : [ 4, 16, 4, 16 ],
"name" : "s"
} ]
}
} ]
}, {
"kind" : "ClassDef",
"location" : [ 6, 1, 36, 0 ],
"name" : {
"kind" : "Identifier",
"location" : [ 6, 7, 6, 9 ],
"name" : "bar"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 6, 11, 6, 16 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 7, 5, 7, 18 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 7, 5, 7, 11 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 7, 5, 7, 5 ],
"name" : "p"
},
"type" : {
"kind" : "ClassType",
"location" : [ 7, 8, 7, 11 ],
"className" : "bool"
}
},
"value" : {
"kind" : "BooleanLiteral",
"location" : [ 7, 15, 7, 18 ],
"value" : true
}
}, {
"kind" : "FuncDef",
"location" : [ 9, 5, 34, 22 ],
"name" : {
"kind" : "Identifier",
"location" : [ 9, 9, 9, 11 ],
"name" : "baz"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 9, 13, 9, 22 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 9, 13, 9, 16 ],
"name" : "self"
},
"type" : {
"kind" : "ClassType",
"location" : [ 9, 18, 9, 22 ],
"className" : "bar"
}
}, {
"kind" : "TypedVar",
"location" : [ 9, 25, 9, 33 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 9, 25, 9, 26 ],
"name" : "xx"
},
"type" : {
"kind" : "ListType",
"location" : [ 9, 29, 9, 33 ],
"elementType" : {
"kind" : "ClassType",
"location" : [ 9, 30, 9, 32 ],
"className" : "int"
}
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 9, 39, 9, 41 ],
"className" : "str"
},
"declarations" : [ {
"kind" : "GlobalDecl",
"location" : [ 10, 9, 10, 20 ],
"variable" : {
"kind" : "Identifier",
"location" : [ 10, 16, 10, 20 ],
"name" : "count"
}
}, {
"kind" : "VarDef",
"location" : [ 11, 9, 11, 17 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 11, 9, 11, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 11, 9, 11, 9 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 11, 11, 11, 13 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 11, 17, 11, 17 ],
"value" : 0
}
}, {
"kind" : "VarDef",
"location" : [ 12, 9, 12, 17 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 12, 9, 12, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 12, 9, 12, 9 ],
"name" : "y"
},
"type" : {
"kind" : "ClassType",
"location" : [ 12, 11, 12, 13 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 12, 17, 12, 17 ],
"value" : 1
}
}, {
"kind" : "FuncDef",
"location" : [ 14, 9, 19, 8 ],
"name" : {
"kind" : "Identifier",
"location" : [ 14, 13, 14, 15 ],
"name" : "qux"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 14, 17, 14, 22 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 14, 17, 14, 17 ],
"name" : "y"
},
"type" : {
"kind" : "ClassType",
"location" : [ 14, 20, 14, 22 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 14, 28, 14, 33 ],
"className" : "object"
},
"declarations" : [ {
"kind" : "NonLocalDecl",
"location" : [ 15, 13, 15, 22 ],
"variable" : {
"kind" : "Identifier",
"location" : [ 15, 22, 15, 22 ],
"name" : "x"
}
} ],
"statements" : [ {
"kind" : "IfStmt",
"location" : [ 16, 13, 19, 8 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 16, 16, 16, 20 ],
"left" : {
"kind" : "Identifier",
"location" : [ 16, 16, 16, 16 ],
"name" : "x"
},
"operator" : ">",
"right" : {
"kind" : "Identifier",
"location" : [ 16, 20, 16, 20 ],
"name" : "y"
}
},
"thenBody" : [ {
"kind" : "AssignStmt",
"location" : [ 17, 17, 17, 22 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 17, 17, 17, 17 ],
"name" : "x"
} ],
"value" : {
"kind" : "UnaryExpr",
"location" : [ 17, 21, 17, 22 ],
"operator" : "-",
"operand" : {
"kind" : "IntegerLiteral",
"location" : [ 17, 22, 17, 22 ],
"value" : 1
}
}
} ],
"elseBody" : [ ]
} ]
} ],
"statements" : [ {
"kind" : "ForStmt",
"location" : [ 19, 9, 22, 8 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 19, 13, 19, 13 ],
"name" : "x"
},
"iterable" : {
"kind" : "Identifier",
"location" : [ 19, 18, 19, 19 ],
"name" : "xx"
},
"body" : [ {
"kind" : "AssignStmt",
"location" : [ 20, 13, 20, 27 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 20, 13, 20, 18 ],
"object" : {
"kind" : "Identifier",
"location" : [ 20, 13, 20, 16 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 20, 18, 20, 18 ],
"name" : "p"
}
} ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 20, 22, 20, 27 ],
"left" : {
"kind" : "Identifier",
"location" : [ 20, 22, 20, 22 ],
"name" : "x"
},
"operator" : "==",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 20, 27, 20, 27 ],
"value" : 2
}
}
} ]
}, {
"kind" : "ExprStmt",
"location" : [ 22, 9, 22, 14 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 22, 9, 22, 14 ],
"function" : {
"kind" : "Identifier",
"location" : [ 22, 9, 22, 11 ],
"name" : "qux"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 22, 13, 22, 13 ],
"value" : 0
} ]
}
}, {
"kind" : "AssignStmt",
"location" : [ 24, 9, 24, 25 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 24, 9, 24, 13 ],
"name" : "count"
} ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 24, 17, 24, 25 ],
"left" : {
"kind" : "Identifier",
"location" : [ 24, 17, 24, 21 ],
"name" : "count"
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 24, 25, 24, 25 ],
"value" : 1
}
}
}, {
"kind" : "WhileStmt",
"location" : [ 26, 9, 34, 8 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 26, 15, 26, 20 ],
"left" : {
"kind" : "Identifier",
"location" : [ 26, 15, 26, 15 ],
"name" : "x"
},
"operator" : "<=",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 26, 20, 26, 20 ],
"value" : 0
}
},
"body" : [ {
"kind" : "IfStmt",
"location" : [ 27, 13, 34, 8 ],
"condition" : {
"kind" : "MemberExpr",
"location" : [ 27, 16, 27, 21 ],
"object" : {
"kind" : "Identifier",
"location" : [ 27, 16, 27, 19 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 27, 21, 27, 21 ],
"name" : "p"
}
},
"thenBody" : [ {
"kind" : "AssignStmt",
"location" : [ 28, 17, 28, 29 ],
"targets" : [ {
"kind" : "IndexExpr",
"location" : [ 28, 17, 28, 21 ],
"list" : {
"kind" : "Identifier",
"location" : [ 28, 17, 28, 18 ],
"name" : "xx"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 28, 20, 28, 20 ],
"value" : 0
}
} ],
"value" : {
"kind" : "IndexExpr",
"location" : [ 28, 25, 28, 29 ],
"list" : {
"kind" : "Identifier",
"location" : [ 28, 25, 28, 26 ],
"name" : "xx"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 28, 28, 28, 28 ],
"value" : 1
}
}
}, {
"kind" : "AssignStmt",
"location" : [ 29, 17, 29, 35 ],
"targets" : [ {
"kind" : "MemberExpr",
"location" : [ 29, 17, 29, 22 ],
"object" : {
"kind" : "Identifier",
"location" : [ 29, 17, 29, 20 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 29, 22, 29, 22 ],
"name" : "p"
}
} ],
"value" : {
"kind" : "UnaryExpr",
"location" : [ 29, 26, 29, 35 ],
"operator" : "not",
"operand" : {
"kind" : "MemberExpr",
"location" : [ 29, 30, 29, 35 ],
"object" : {
"kind" : "Identifier",
"location" : [ 29, 30, 29, 33 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 29, 35, 29, 35 ],
"name" : "p"
}
}
}
}, {
"kind" : "AssignStmt",
"location" : [ 30, 17, 30, 25 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 30, 17, 30, 17 ],
"name" : "x"
} ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 30, 21, 30, 25 ],
"left" : {
"kind" : "Identifier",
"location" : [ 30, 21, 30, 21 ],
"name" : "x"
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 30, 25, 30, 25 ],
"value" : 1
}
}
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 31, 13, 34, 8 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 31, 18, 31, 36 ],
"left" : {
"kind" : "CallExpr",
"location" : [ 31, 18, 31, 31 ],
"function" : {
"kind" : "Identifier",
"location" : [ 31, 18, 31, 20 ],
"name" : "foo"
},
"args" : [ {
"kind" : "IndexExpr",
"location" : [ 31, 22, 31, 30 ],
"list" : {
"kind" : "StringLiteral",
"location" : [ 31, 22, 31, 27 ],
"value" : "Long"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 31, 29, 31, 29 ],
"value" : 0
}
} ]
},
"operator" : "==",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 31, 36, 31, 36 ],
"value" : 1
}
},
"thenBody" : [ {
"kind" : "ReturnStmt",
"location" : [ 32, 17, 32, 35 ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 32, 24, 32, 35 ],
"left" : {
"kind" : "Identifier",
"location" : [ 32, 24, 32, 27 ],
"name" : "self"
},
"operator" : "is",
"right" : {
"kind" : "NoneLiteral",
"location" : [ 32, 32, 32, 35 ]
}
}
} ],
"elseBody" : [ ]
} ]
} ]
}, {
"kind" : "ReturnStmt",
"location" : [ 34, 9, 34, 21 ],
"value" : {
"kind" : "StringLiteral",
"location" : [ 34, 16, 34, 21 ],
"value" : "Nope"
}
} ]
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 36, 1, 36, 23 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 36, 1, 36, 23 ],
"function" : {
"kind" : "Identifier",
"location" : [ 36, 1, 36, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "MethodCallExpr",
"location" : [ 36, 7, 36, 22 ],
"method" : {
"kind" : "MemberExpr",
"location" : [ 36, 7, 36, 15 ],
"object" : {
"kind" : "CallExpr",
"location" : [ 36, 7, 36, 11 ],
"function" : {
"kind" : "Identifier",
"location" : [ 36, 7, 36, 9 ],
"name" : "bar"
},
"args" : [ ]
},
"member" : {
"kind" : "Identifier",
"location" : [ 36, 13, 36, 15 ],
"name" : "baz"
}
},
"args" : [ {
"kind" : "ListExpr",
"location" : [ 36, 17, 36, 21 ],
"elements" : [ {
"kind" : "IntegerLiteral",
"location" : [ 36, 18, 36, 18 ],
"value" : 1
}, {
"kind" : "IntegerLiteral",
"location" : [ 36, 20, 36, 20 ],
"value" : 2
} ]
} ]
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/def_func.py
Unescape View File

@ -0,0 +1,4 @@
def foo() -> int:
return 1
foo()

48
pa1-tests/core/def_func.py.ast
Unescape View File

@ -0,0 +1,48 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 6 ],
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 1, 1, 2, 13 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 5, 1, 7 ],
"name" : "foo"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 1, 14, 1, 16 ],
"className" : "int"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 2, 5, 2, 12 ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 2, 12, 2, 12 ],
"value" : 1
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 4, 1, 4, 5 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 4, 1, 4, 5 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 3 ],
"name" : "foo"
},
"args" : [ ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/def_func_args.py
Unescape View File

@ -0,0 +1,4 @@
def foo(x:int, y:int) -> bool:
return x > y
foo(1,2)

92
pa1-tests/core/def_func_args.py.ast
Unescape View File

@ -0,0 +1,92 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 9 ],
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 1, 1, 2, 17 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 5, 1, 7 ],
"name" : "foo"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 1, 9, 1, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 9, 1, 9 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 11, 1, 13 ],
"className" : "int"
}
}, {
"kind" : "TypedVar",
"location" : [ 1, 16, 1, 20 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 16, 1, 16 ],
"name" : "y"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 18, 1, 20 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 1, 26, 1, 29 ],
"className" : "bool"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 2, 5, 2, 16 ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 2, 12, 2, 16 ],
"left" : {
"kind" : "Identifier",
"location" : [ 2, 12, 2, 12 ],
"name" : "x"
},
"operator" : ">",
"right" : {
"kind" : "Identifier",
"location" : [ 2, 16, 2, 16 ],
"name" : "y"
}
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 4, 1, 4, 8 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 4, 1, 4, 8 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 3 ],
"name" : "foo"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 4, 5, 4, 5 ],
"value" : 1
}, {
"kind" : "IntegerLiteral",
"location" : [ 4, 7, 4, 7 ],
"value" : 2
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

7
pa1-tests/core/def_func_global.py
Unescape View File

@ -0,0 +1,7 @@
z:int = 0
def foo(x:int) -> bool:
global z
return x > z
foo(1)

105
pa1-tests/core/def_func_global.py.ast
Unescape View File

@ -0,0 +1,105 @@
{
"kind" : "Program",
"location" : [ 1, 1, 7, 7 ],
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 1, 1, 1, 9 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 1, 1, 1, 5 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "z"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 3, 1, 5 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 9, 1, 9 ],
"value" : 0
}
}, {
"kind" : "FuncDef",
"location" : [ 3, 1, 5, 17 ],
"name" : {
"kind" : "Identifier",
"location" : [ 3, 5, 3, 7 ],
"name" : "foo"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 3, 9, 3, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 3, 9, 3, 9 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 3, 11, 3, 13 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 3, 19, 3, 22 ],
"className" : "bool"
},
"declarations" : [ {
"kind" : "GlobalDecl",
"location" : [ 4, 5, 4, 12 ],
"variable" : {
"kind" : "Identifier",
"location" : [ 4, 12, 4, 12 ],
"name" : "z"
}
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 5, 5, 5, 16 ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 5, 12, 5, 16 ],
"left" : {
"kind" : "Identifier",
"location" : [ 5, 12, 5, 12 ],
"name" : "x"
},
"operator" : ">",
"right" : {
"kind" : "Identifier",
"location" : [ 5, 16, 5, 16 ],
"name" : "z"
}
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 7, 1, 7, 6 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 7, 1, 7, 6 ],
"function" : {
"kind" : "Identifier",
"location" : [ 7, 1, 7, 3 ],
"name" : "foo"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 7, 5, 7, 5 ],
"value" : 1
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

10
pa1-tests/core/def_func_nested.py
Unescape View File

@ -0,0 +1,10 @@
def foo(x:int) -> bool:
a:int = 0
b:int = 1
def bar(y: int) -> int:
a:int = 2
return y
return bar(x) > a
foo(1)

187
pa1-tests/core/def_func_nested.py.ast
Unescape View File

@ -0,0 +1,187 @@
{
"kind" : "Program",
"location" : [ 2, 1, 10, 7 ],
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 2, 1, 8, 22 ],
"name" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 7 ],
"name" : "foo"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 2, 9, 2, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 9, 2, 9 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 11, 2, 13 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 2, 19, 2, 22 ],
"className" : "bool"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 3, 5, 3, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 3, 5, 3, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 3, 5, 3, 5 ],
"name" : "a"
},
"type" : {
"kind" : "ClassType",
"location" : [ 3, 7, 3, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 13, 3, 13 ],
"value" : 0
}
}, {
"kind" : "VarDef",
"location" : [ 4, 5, 4, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 4, 5, 4, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 5 ],
"name" : "b"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 7, 4, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 4, 13, 4, 13 ],
"value" : 1
}
}, {
"kind" : "FuncDef",
"location" : [ 5, 5, 7, 17 ],
"name" : {
"kind" : "Identifier",
"location" : [ 5, 9, 5, 11 ],
"name" : "bar"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 5, 13, 5, 18 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 5, 13, 5, 13 ],
"name" : "y"
},
"type" : {
"kind" : "ClassType",
"location" : [ 5, 16, 5, 18 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 5, 24, 5, 26 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 6, 9, 6, 17 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 6, 9, 6, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 6, 9, 6, 9 ],
"name" : "a"
},
"type" : {
"kind" : "ClassType",
"location" : [ 6, 11, 6, 13 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 6, 17, 6, 17 ],
"value" : 2
}
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 7, 9, 7, 16 ],
"value" : {
"kind" : "Identifier",
"location" : [ 7, 16, 7, 16 ],
"name" : "y"
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 8, 5, 8, 21 ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 8, 12, 8, 21 ],
"left" : {
"kind" : "CallExpr",
"location" : [ 8, 12, 8, 17 ],
"function" : {
"kind" : "Identifier",
"location" : [ 8, 12, 8, 14 ],
"name" : "bar"
},
"args" : [ {
"kind" : "Identifier",
"location" : [ 8, 16, 8, 16 ],
"name" : "x"
} ]
},
"operator" : ">",
"right" : {
"kind" : "Identifier",
"location" : [ 8, 21, 8, 21 ],
"name" : "a"
}
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 10, 1, 10, 6 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 10, 1, 10, 6 ],
"function" : {
"kind" : "Identifier",
"location" : [ 10, 1, 10, 3 ],
"name" : "foo"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 10, 5, 10, 5 ],
"value" : 1
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

11
pa1-tests/core/def_func_nonlocal.py
Unescape View File

@ -0,0 +1,11 @@
def foo(x:int) -> bool:
a:int = 0
b:int = 1
def bar(y: int) -> int:
nonlocal a
a = 2
return y
return bar(x) > a
foo(1)

186
pa1-tests/core/def_func_nonlocal.py.ast
Unescape View File

@ -0,0 +1,186 @@
{
"kind" : "Program",
"location" : [ 2, 1, 11, 7 ],
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 2, 1, 9, 22 ],
"name" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 7 ],
"name" : "foo"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 2, 9, 2, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 9, 2, 9 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 11, 2, 13 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 2, 19, 2, 22 ],
"className" : "bool"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 3, 5, 3, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 3, 5, 3, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 3, 5, 3, 5 ],
"name" : "a"
},
"type" : {
"kind" : "ClassType",
"location" : [ 3, 7, 3, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 13, 3, 13 ],
"value" : 0
}
}, {
"kind" : "VarDef",
"location" : [ 4, 5, 4, 13 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 4, 5, 4, 9 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 5 ],
"name" : "b"
},
"type" : {
"kind" : "ClassType",
"location" : [ 4, 7, 4, 9 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 4, 13, 4, 13 ],
"value" : 1
}
}, {
"kind" : "FuncDef",
"location" : [ 5, 5, 8, 17 ],
"name" : {
"kind" : "Identifier",
"location" : [ 5, 9, 5, 11 ],
"name" : "bar"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 5, 13, 5, 18 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 5, 13, 5, 13 ],
"name" : "y"
},
"type" : {
"kind" : "ClassType",
"location" : [ 5, 16, 5, 18 ],
"className" : "int"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 5, 24, 5, 26 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "NonLocalDecl",
"location" : [ 6, 9, 6, 18 ],
"variable" : {
"kind" : "Identifier",
"location" : [ 6, 18, 6, 18 ],
"name" : "a"
}
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 7, 9, 7, 13 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 7, 9, 7, 9 ],
"name" : "a"
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 7, 13, 7, 13 ],
"value" : 2
}
}, {
"kind" : "ReturnStmt",
"location" : [ 8, 9, 8, 16 ],
"value" : {
"kind" : "Identifier",
"location" : [ 8, 16, 8, 16 ],
"name" : "y"
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 9, 5, 9, 21 ],
"value" : {
"kind" : "BinaryExpr",
"location" : [ 9, 12, 9, 21 ],
"left" : {
"kind" : "CallExpr",
"location" : [ 9, 12, 9, 17 ],
"function" : {
"kind" : "Identifier",
"location" : [ 9, 12, 9, 14 ],
"name" : "bar"
},
"args" : [ {
"kind" : "Identifier",
"location" : [ 9, 16, 9, 16 ],
"name" : "x"
} ]
},
"operator" : ">",
"right" : {
"kind" : "Identifier",
"location" : [ 9, 21, 9, 21 ],
"name" : "a"
}
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 11, 1, 11, 6 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 11, 1, 11, 6 ],
"function" : {
"kind" : "Identifier",
"location" : [ 11, 1, 11, 3 ],
"name" : "foo"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 11, 5, 11, 5 ],
"value" : 1
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/expr_if.py
Unescape View File

@ -0,0 +1 @@
3 if 1 > 2 else 4

43
pa1-tests/core/expr_if.py.ast
Unescape View File

@ -0,0 +1,43 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 18 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 17 ],
"expr" : {
"kind" : "IfExpr",
"location" : [ 1, 1, 1, 17 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 1, 6, 1, 10 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 6, 1, 6 ],
"value" : 1
},
"operator" : ">",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 10, 1, 10 ],
"value" : 2
}
},
"thenExpr" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 1, 1, 1 ],
"value" : 3
},
"elseExpr" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 17, 1, 17 ],
"value" : 4
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/expr_if_chained.py
Unescape View File

@ -0,0 +1 @@
3 if 1 > 2 else 4 if 1 < 0 else 5

67
pa1-tests/core/expr_if_chained.py.ast
Unescape View File

@ -0,0 +1,67 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 34 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 33 ],
"expr" : {
"kind" : "IfExpr",
"location" : [ 1, 1, 1, 33 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 1, 6, 1, 10 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 6, 1, 6 ],
"value" : 1
},
"operator" : ">",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 10, 1, 10 ],
"value" : 2
}
},
"thenExpr" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 1, 1, 1 ],
"value" : 3
},
"elseExpr" : {
"kind" : "IfExpr",
"location" : [ 1, 17, 1, 33 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 1, 22, 1, 26 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 22, 1, 22 ],
"value" : 1
},
"operator" : "<",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 26, 1, 26 ],
"value" : 0
}
},
"thenExpr" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 17, 1, 17 ],
"value" : 4
},
"elseExpr" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 33, 1, 33 ],
"value" : 5
}
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/expr_index.py
Unescape View File

@ -0,0 +1 @@
a + b[i][j]

47
pa1-tests/core/expr_index.py.ast
Unescape View File

@ -0,0 +1,47 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 12 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 11 ],
"expr" : {
"kind" : "BinaryExpr",
"location" : [ 1, 1, 1, 11 ],
"left" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "a"
},
"operator" : "+",
"right" : {
"kind" : "IndexExpr",
"location" : [ 1, 5, 1, 11 ],
"list" : {
"kind" : "IndexExpr",
"location" : [ 1, 5, 1, 8 ],
"list" : {
"kind" : "Identifier",
"location" : [ 1, 5, 1, 5 ],
"name" : "b"
},
"index" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 7 ],
"name" : "i"
}
},
"index" : {
"kind" : "Identifier",
"location" : [ 1, 10, 1, 10 ],
"name" : "j"
}
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/expr_plus.py
Unescape View File

@ -0,0 +1 @@
1 + 2 + 3

39
pa1-tests/core/expr_plus.py.ast
Unescape View File

@ -0,0 +1,39 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 10 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 9 ],
"expr" : {
"kind" : "BinaryExpr",
"location" : [ 1, 1, 1, 9 ],
"left" : {
"kind" : "BinaryExpr",
"location" : [ 1, 1, 1, 5 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 1, 1, 1 ],
"value" : 1
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 5, 1, 5 ],
"value" : 2
}
},
"operator" : "+",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 9, 1, 9 ],
"value" : 3
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/expr_unary.py
Unescape View File

@ -0,0 +1 @@
-1

24
pa1-tests/core/expr_unary.py.ast
Unescape View File

@ -0,0 +1,24 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 3 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 2 ],
"expr" : {
"kind" : "UnaryExpr",
"location" : [ 1, 1, 1, 2 ],
"operator" : "-",
"operand" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 2, 1, 2 ],
"value" : 1
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

5
pa1-tests/core/global.py
Unescape View File

@ -0,0 +1,5 @@
x:int = 1
x = 2
print(x)

63
pa1-tests/core/global.py.ast
Unescape View File

@ -0,0 +1,63 @@
{
"kind" : "Program",
"location" : [ 1, 1, 5, 9 ],
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 1, 1, 1, 9 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 1, 1, 1, 5 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 3, 1, 5 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 9, 1, 9 ],
"value" : 1
}
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 3, 1, 3, 5 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 3, 1, 3, 1 ],
"name" : "x"
} ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 5, 3, 5 ],
"value" : 2
}
}, {
"kind" : "ExprStmt",
"location" : [ 5, 1, 5, 8 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 5, 1, 5, 8 ],
"function" : {
"kind" : "Identifier",
"location" : [ 5, 1, 5, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "Identifier",
"location" : [ 5, 7, 5, 7 ],
"name" : "x"
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

7
pa1-tests/core/literals.py
Unescape View File

@ -0,0 +1,7 @@
True
False
1
None
"This is a string"
[1, 2, 3]

70
pa1-tests/core/literals.py.ast
Unescape View File

@ -0,0 +1,70 @@
{
"kind" : "Program",
"location" : [ 1, 1, 6, 10 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 4 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 1, 1, 1, 4 ],
"value" : true
}
}, {
"kind" : "ExprStmt",
"location" : [ 2, 1, 2, 5 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 2, 1, 2, 5 ],
"value" : false
}
}, {
"kind" : "ExprStmt",
"location" : [ 3, 1, 3, 1 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 1, 3, 1 ],
"value" : 1
}
}, {
"kind" : "ExprStmt",
"location" : [ 4, 1, 4, 4 ],
"expr" : {
"kind" : "NoneLiteral",
"location" : [ 4, 1, 4, 4 ]
}
}, {
"kind" : "ExprStmt",
"location" : [ 5, 1, 5, 18 ],
"expr" : {
"kind" : "StringLiteral",
"location" : [ 5, 1, 5, 18 ],
"value" : "This is a string"
}
}, {
"kind" : "ExprStmt",
"location" : [ 6, 1, 6, 9 ],
"expr" : {
"kind" : "ListExpr",
"location" : [ 6, 1, 6, 9 ],
"elements" : [ {
"kind" : "IntegerLiteral",
"location" : [ 6, 2, 6, 2 ],
"value" : 1
}, {
"kind" : "IntegerLiteral",
"location" : [ 6, 5, 6, 5 ],
"value" : 2
}, {
"kind" : "IntegerLiteral",
"location" : [ 6, 8, 6, 8 ],
"value" : 3
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

1
pa1-tests/core/stmt_call.py
Unescape View File

@ -0,0 +1 @@
print(1)

28
pa1-tests/core/stmt_call.py.ast
Unescape View File

@ -0,0 +1,28 @@
{
"kind" : "Program",
"location" : [ 1, 1, 1, 9 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 1, 1, 1, 8 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 1, 1, 1, 8 ],
"function" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 5 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 1, 7, 1, 7 ],
"value" : 1
} ]
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/stmt_for.py
Unescape View File

@ -0,0 +1,4 @@
x:int = 0
for x in [1, 2, 3]:
print(x)

76
pa1-tests/core/stmt_for.py.ast
Unescape View File

@ -0,0 +1,76 @@
{
"kind" : "Program",
"location" : [ 1, 1, 5, 1 ],
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 1, 1, 1, 9 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 1, 1, 1, 5 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 3, 1, 5 ],
"className" : "int"
}
},
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 9, 1, 9 ],
"value" : 0
}
} ],
"statements" : [ {
"kind" : "ForStmt",
"location" : [ 2, 1, 5, 1 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "x"
},
"iterable" : {
"kind" : "ListExpr",
"location" : [ 2, 10, 2, 18 ],
"elements" : [ {
"kind" : "IntegerLiteral",
"location" : [ 2, 11, 2, 11 ],
"value" : 1
}, {
"kind" : "IntegerLiteral",
"location" : [ 2, 14, 2, 14 ],
"value" : 2
}, {
"kind" : "IntegerLiteral",
"location" : [ 2, 17, 2, 17 ],
"value" : 3
} ]
},
"body" : [ {
"kind" : "ExprStmt",
"location" : [ 3, 5, 3, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 3, 5, 3, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 3, 5, 3, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "Identifier",
"location" : [ 3, 11, 3, 11 ],
"name" : "x"
} ]
}
} ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

3
pa1-tests/core/stmt_if.py
Unescape View File

@ -0,0 +1,3 @@
if True:
False

29
pa1-tests/core/stmt_if.py.ast
Unescape View File

@ -0,0 +1,29 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 1 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "IfStmt",
"location" : [ 1, 1, 4, 1 ],
"condition" : {
"kind" : "BooleanLiteral",
"location" : [ 1, 4, 1, 7 ],
"value" : true
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 2, 5, 2, 9 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 2, 5, 2, 9 ],
"value" : false
}
} ],
"elseBody" : [ ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

6
pa1-tests/core/stmt_if_elif.py
Unescape View File

@ -0,0 +1,6 @@
if 1 > 2:
print(1)
elif 3 == 4:
print(2)
elif True:
print(3)

112
pa1-tests/core/stmt_if_elif.py.ast
Unescape View File

@ -0,0 +1,112 @@
{
"kind" : "Program",
"location" : [ 1, 1, 7, 1 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "IfStmt",
"location" : [ 1, 1, 7, 1 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 1, 4, 1, 8 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 4, 1, 4 ],
"value" : 1
},
"operator" : ">",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 8, 1, 8 ],
"value" : 2
}
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 2, 5, 2, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 2, 5, 2, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 2, 11, 2, 11 ],
"value" : 1
} ]
}
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 3, 1, 7, 1 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 3, 6, 3, 11 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 6, 3, 6 ],
"value" : 3
},
"operator" : "==",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 11, 3, 11 ],
"value" : 4
}
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 4, 5, 4, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 4, 5, 4, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 4, 11, 4, 11 ],
"value" : 2
} ]
}
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 5, 1, 7, 1 ],
"condition" : {
"kind" : "BooleanLiteral",
"location" : [ 5, 6, 5, 9 ],
"value" : true
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 6, 5, 6, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 6, 5, 6, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 6, 5, 6, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 6, 11, 6, 11 ],
"value" : 3
} ]
}
} ],
"elseBody" : [ ]
} ]
} ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

8
pa1-tests/core/stmt_if_elif_else.py
Unescape View File

@ -0,0 +1,8 @@
if 1 > 2:
print(1)
elif 3 == 4:
print(2)
elif True:
print(3)
else:
print(4)

129
pa1-tests/core/stmt_if_elif_else.py.ast
Unescape View File

@ -0,0 +1,129 @@
{
"kind" : "Program",
"location" : [ 1, 1, 9, 1 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "IfStmt",
"location" : [ 1, 1, 9, 1 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 1, 4, 1, 8 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 4, 1, 4 ],
"value" : 1
},
"operator" : ">",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 1, 8, 1, 8 ],
"value" : 2
}
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 2, 5, 2, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 2, 5, 2, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 2, 11, 2, 11 ],
"value" : 1
} ]
}
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 3, 1, 9, 1 ],
"condition" : {
"kind" : "BinaryExpr",
"location" : [ 3, 6, 3, 11 ],
"left" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 6, 3, 6 ],
"value" : 3
},
"operator" : "==",
"right" : {
"kind" : "IntegerLiteral",
"location" : [ 3, 11, 3, 11 ],
"value" : 4
}
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 4, 5, 4, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 4, 5, 4, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 4, 5, 4, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 4, 11, 4, 11 ],
"value" : 2
} ]
}
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 5, 1, 9, 1 ],
"condition" : {
"kind" : "BooleanLiteral",
"location" : [ 5, 6, 5, 9 ],
"value" : true
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 6, 5, 6, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 6, 5, 6, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 6, 5, 6, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 6, 11, 6, 11 ],
"value" : 3
} ]
}
} ],
"elseBody" : [ {
"kind" : "ExprStmt",
"location" : [ 8, 5, 8, 12 ],
"expr" : {
"kind" : "CallExpr",
"location" : [ 8, 5, 8, 12 ],
"function" : {
"kind" : "Identifier",
"location" : [ 8, 5, 8, 9 ],
"name" : "print"
},
"args" : [ {
"kind" : "IntegerLiteral",
"location" : [ 8, 11, 8, 11 ],
"value" : 4
} ]
}
} ]
} ]
} ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

5
pa1-tests/core/stmt_ifelse.py
Unescape View File

@ -0,0 +1,5 @@
if True:
False
else:
True

37
pa1-tests/core/stmt_ifelse.py.ast
Unescape View File

@ -0,0 +1,37 @@
{
"kind" : "Program",
"location" : [ 1, 1, 6, 1 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "IfStmt",
"location" : [ 1, 1, 6, 1 ],
"condition" : {
"kind" : "BooleanLiteral",
"location" : [ 1, 4, 1, 7 ],
"value" : true
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 2, 5, 2, 9 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 2, 5, 2, 9 ],
"value" : false
}
} ],
"elseBody" : [ {
"kind" : "ExprStmt",
"location" : [ 4, 5, 4, 8 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 4, 5, 4, 8 ],
"value" : true
}
} ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

4
pa1-tests/core/stmt_list_assign.py
Unescape View File

@ -0,0 +1,4 @@
x:int = None
x = [1, 2, 3]
x[0] = x[1]

88
pa1-tests/core/stmt_list_assign.py.ast
Unescape View File

@ -0,0 +1,88 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 12 ],
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 1, 1, 1, 12 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 1, 1, 1, 5 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 1, 1, 1, 1 ],
"name" : "x"
},
"type" : {
"kind" : "ClassType",
"location" : [ 1, 3, 1, 5 ],
"className" : "int"
}
},
"value" : {
"kind" : "NoneLiteral",
"location" : [ 1, 9, 1, 12 ]
}
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 3, 1, 3, 13 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 3, 1, 3, 1 ],
"name" : "x"
} ],
"value" : {
"kind" : "ListExpr",
"location" : [ 3, 5, 3, 13 ],
"elements" : [ {
"kind" : "IntegerLiteral",
"location" : [ 3, 6, 3, 6 ],
"value" : 1
}, {
"kind" : "IntegerLiteral",
"location" : [ 3, 9, 3, 9 ],
"value" : 2
}, {
"kind" : "IntegerLiteral",
"location" : [ 3, 12, 3, 12 ],
"value" : 3
} ]
}
}, {
"kind" : "AssignStmt",
"location" : [ 4, 1, 4, 11 ],
"targets" : [ {
"kind" : "IndexExpr",
"location" : [ 4, 1, 4, 4 ],
"list" : {
"kind" : "Identifier",
"location" : [ 4, 1, 4, 1 ],
"name" : "x"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 4, 3, 4, 3 ],
"value" : 0
}
} ],
"value" : {
"kind" : "IndexExpr",
"location" : [ 4, 8, 4, 11 ],
"list" : {
"kind" : "Identifier",
"location" : [ 4, 8, 4, 8 ],
"name" : "x"
},
"index" : {
"kind" : "IntegerLiteral",
"location" : [ 4, 10, 4, 10 ],
"value" : 1
}
}
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

3
pa1-tests/core/stmt_while.py
Unescape View File

@ -0,0 +1,3 @@
while True:
pass

20
pa1-tests/core/stmt_while.py.ast
Unescape View File

@ -0,0 +1,20 @@
{
"kind" : "Program",
"location" : [ 1, 1, 4, 1 ],
"declarations" : [ ],
"statements" : [ {
"kind" : "WhileStmt",
"location" : [ 1, 1, 4, 1 ],
"condition" : {
"kind" : "BooleanLiteral",
"location" : [ 1, 7, 1, 10 ],
"value" : true
},
"body" : [ ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

52
pa1-tests/extra/graph.py
Unescape View File

@ -0,0 +1,52 @@
class weight(object):
value: int = 0
def __init__(self: "weight", value: int):
self.value = value
def __repr__(self: "weight"):
return "weight(" + str(self.value) + ")"
class graph(object):
matrix: [[weight]] = None
def __init__(self: "graph", num_vertices: int):
i: int = 0
j: int = 0
row: [weight] = None
self.matrix = []
while i < num_vertices:
j = 0
row = []
while j < num_vertices:
row = row + [weight(0)]
j = j + 1
self.matrix = self.matrix + [row]
i = i + 1
def add_edge(self: "graph", from_vertex: int, to_vertex: int, edge_weight: int):
pass
def print(self: "graph"):
for row in self.matrix:
print(row)
class undirectedgraph(graph):
def add_edge(self: "undirectedgraph", from_vertex: int, to_vertex: int, edge_weight: int):
self.matrix[from_vertex][to_vertex] = weight(edge_weight)
self.matrix[to_vertex][from_vertex] = weight(edge_weight)
class directedgraph(graph):
def add_edge(self: "undirectedgraph", from_vertex: int, to_vertex: int, edge_weight: int):
self.matrix[from_vertex][to_vertex] = weight(edge_weight)
g = undirectedgraph(3)
g.add_edge(0, 2, 100)
g.print()
directedgraph(3).print()

1110
pa1-tests/extra/graph.py.ast
View File

File diff suppressed because it is too large Load Diff

62
pa1-tests/extra/mergesort.py
Unescape View File

@ -0,0 +1,62 @@
def append(a: [int], k: int) -> [int]:
return a + [k]
def extend(a: [int], b: [int], b_start: int, b_end: int) -> [int]:
extended: [int] = None
i: int = 0
extended = a
i = b_start
while i < b_end:
extended = append(extended, b[i])
i = i + 1
return extended
def merge(left: [int], right: [int]) -> [int]:
merged: [int] = None
i: int = 0
j: int = 0
merged = []
while i < len(left) and j < len(right):
if left[i] < right[j]:
merged = append(merged, left[i])
i = i + 1
else:
merged = append(merged, right[j])
j = j + 1
if i < len(left):
merged = extend(merged, left, i, len(left))
if j < len(right):
merged = extend(merged, right, j, len(right))
return merged
def mergesort(a: [int]) -> [int]:
mid: int = 0
left: [int] = None
right: [int] = None
if len(a) < 2:
return a
mid = len(a) // 2
left = extend([], a, 0, mid)
right = extend([], a, mid, len(a))
left = mergesort(left)
right = mergesort(right)
return merge(left, right)
initial: [int] = None
ordered: [int] = None
initial = [2, 7, 3, 11, 5]
ordered = mergesort(initial)
print(ordered)

1262
pa1-tests/extra/mergesort.py.ast
View File

File diff suppressed because it is too large Load Diff

45
pa1-tests/extra/nesting.py
Unescape View File

@ -0,0 +1,45 @@
class s(object):
t: object = None
class r(object):
sobj: s = None
class q(object):
robj: r = None
class p(q):
def f(self: "p") -> object:
return self.robj.sobj.t
def a() -> int:
def b() -> int:
def c() -> int:
def d() -> int:
def e() -> int:
return 1
return e()
return d()
return c()
return b()
def w():
def x():
def y():
def z():
4
3
2
1
xs: [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[int]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] = None
xs = [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
if 1:
if 2:
if 3:
if 4:
True
elif -3:
False
else:
False

799
pa1-tests/extra/nesting.py.ast
Unescape View File

@ -0,0 +1,799 @@
{
"kind" : "Program",
"location" : [ 1, 1, 46, 1 ],
"declarations" : [ {
"kind" : "ClassDef",
"location" : [ 1, 1, 2, 21 ],
"name" : {
"kind" : "Identifier",
"location" : [ 1, 7, 1, 7 ],
"name" : "s"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 1, 9, 1, 14 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 2, 5, 2, 20 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 2, 5, 2, 13 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 2, 5, 2, 5 ],
"name" : "t"
},
"type" : {
"kind" : "ClassType",
"location" : [ 2, 8, 2, 13 ],
"className" : "object"
}
},
"value" : {
"kind" : "NoneLiteral",
"location" : [ 2, 17, 2, 20 ]
}
} ]
}, {
"kind" : "ClassDef",
"location" : [ 4, 1, 5, 19 ],
"name" : {
"kind" : "Identifier",
"location" : [ 4, 7, 4, 7 ],
"name" : "r"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 4, 9, 4, 14 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 5, 5, 5, 18 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 5, 5, 5, 11 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 5, 5, 5, 8 ],
"name" : "sobj"
},
"type" : {
"kind" : "ClassType",
"location" : [ 5, 11, 5, 11 ],
"className" : "s"
}
},
"value" : {
"kind" : "NoneLiteral",
"location" : [ 5, 15, 5, 18 ]
}
} ]
}, {
"kind" : "ClassDef",
"location" : [ 7, 1, 8, 19 ],
"name" : {
"kind" : "Identifier",
"location" : [ 7, 7, 7, 7 ],
"name" : "q"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 7, 9, 7, 14 ],
"name" : "object"
},
"declarations" : [ {
"kind" : "VarDef",
"location" : [ 8, 5, 8, 18 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 8, 5, 8, 11 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 8, 5, 8, 8 ],
"name" : "robj"
},
"type" : {
"kind" : "ClassType",
"location" : [ 8, 11, 8, 11 ],
"className" : "r"
}
},
"value" : {
"kind" : "NoneLiteral",
"location" : [ 8, 15, 8, 18 ]
}
} ]
}, {
"kind" : "ClassDef",
"location" : [ 10, 1, 14, 0 ],
"name" : {
"kind" : "Identifier",
"location" : [ 10, 7, 10, 7 ],
"name" : "p"
},
"superClass" : {
"kind" : "Identifier",
"location" : [ 10, 9, 10, 9 ],
"name" : "q"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 11, 5, 12, 32 ],
"name" : {
"kind" : "Identifier",
"location" : [ 11, 9, 11, 9 ],
"name" : "f"
},
"params" : [ {
"kind" : "TypedVar",
"location" : [ 11, 11, 11, 19 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 11, 11, 11, 14 ],
"name" : "self"
},
"type" : {
"kind" : "ClassType",
"location" : [ 11, 17, 11, 19 ],
"className" : "p"
}
} ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 11, 25, 11, 30 ],
"className" : "object"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 12, 9, 12, 31 ],
"value" : {
"kind" : "MemberExpr",
"location" : [ 12, 16, 12, 31 ],
"object" : {
"kind" : "MemberExpr",
"location" : [ 12, 16, 12, 29 ],
"object" : {
"kind" : "MemberExpr",
"location" : [ 12, 16, 12, 24 ],
"object" : {
"kind" : "Identifier",
"location" : [ 12, 16, 12, 19 ],
"name" : "self"
},
"member" : {
"kind" : "Identifier",
"location" : [ 12, 21, 12, 24 ],
"name" : "robj"
}
},
"member" : {
"kind" : "Identifier",
"location" : [ 12, 26, 12, 29 ],
"name" : "sobj"
}
},
"member" : {
"kind" : "Identifier",
"location" : [ 12, 31, 12, 31 ],
"name" : "t"
}
}
} ]
} ]
}, {
"kind" : "FuncDef",
"location" : [ 14, 1, 23, 15 ],
"name" : {
"kind" : "Identifier",
"location" : [ 14, 5, 14, 5 ],
"name" : "a"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 14, 12, 14, 14 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 15, 5, 22, 19 ],
"name" : {
"kind" : "Identifier",
"location" : [ 15, 9, 15, 9 ],
"name" : "b"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 15, 16, 15, 18 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 16, 9, 21, 23 ],
"name" : {
"kind" : "Identifier",
"location" : [ 16, 13, 16, 13 ],
"name" : "c"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 16, 20, 16, 22 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 17, 13, 20, 27 ],
"name" : {
"kind" : "Identifier",
"location" : [ 17, 17, 17, 17 ],
"name" : "d"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 17, 24, 17, 26 ],
"className" : "int"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 18, 17, 19, 29 ],
"name" : {
"kind" : "Identifier",
"location" : [ 18, 21, 18, 21 ],
"name" : "e"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 18, 28, 18, 30 ],
"className" : "int"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 19, 21, 19, 28 ],
"value" : {
"kind" : "IntegerLiteral",
"location" : [ 19, 28, 19, 28 ],
"value" : 1
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 20, 17, 20, 26 ],
"value" : {
"kind" : "CallExpr",
"location" : [ 20, 24, 20, 26 ],
"function" : {
"kind" : "Identifier",
"location" : [ 20, 24, 20, 24 ],
"name" : "e"
},
"args" : [ ]
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 21, 13, 21, 22 ],
"value" : {
"kind" : "CallExpr",
"location" : [ 21, 20, 21, 22 ],
"function" : {
"kind" : "Identifier",
"location" : [ 21, 20, 21, 20 ],
"name" : "d"
},
"args" : [ ]
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 22, 9, 22, 18 ],
"value" : {
"kind" : "CallExpr",
"location" : [ 22, 16, 22, 18 ],
"function" : {
"kind" : "Identifier",
"location" : [ 22, 16, 22, 16 ],
"name" : "c"
},
"args" : [ ]
}
} ]
} ],
"statements" : [ {
"kind" : "ReturnStmt",
"location" : [ 23, 5, 23, 14 ],
"value" : {
"kind" : "CallExpr",
"location" : [ 23, 12, 23, 14 ],
"function" : {
"kind" : "Identifier",
"location" : [ 23, 12, 23, 12 ],
"name" : "b"
},
"args" : [ ]
}
} ]
}, {
"kind" : "FuncDef",
"location" : [ 25, 1, 32, 3 ],
"name" : {
"kind" : "Identifier",
"location" : [ 25, 5, 25, 5 ],
"name" : "w"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 25, 8, 25, 8 ],
"className" : "<None>"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 26, 2, 31, 5 ],
"name" : {
"kind" : "Identifier",
"location" : [ 26, 6, 26, 6 ],
"name" : "x"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 26, 9, 26, 9 ],
"className" : "<None>"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 27, 4, 30, 8 ],
"name" : {
"kind" : "Identifier",
"location" : [ 27, 8, 27, 8 ],
"name" : "y"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 27, 11, 27, 11 ],
"className" : "<None>"
},
"declarations" : [ {
"kind" : "FuncDef",
"location" : [ 28, 7, 29, 12 ],
"name" : {
"kind" : "Identifier",
"location" : [ 28, 11, 28, 11 ],
"name" : "z"
},
"params" : [ ],
"returnType" : {
"kind" : "ClassType",
"location" : [ 28, 14, 28, 14 ],
"className" : "<None>"
},
"declarations" : [ ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 29, 11, 29, 11 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 29, 11, 29, 11 ],
"value" : 4
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 30, 7, 30, 7 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 30, 7, 30, 7 ],
"value" : 3
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 31, 4, 31, 4 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 31, 4, 31, 4 ],
"value" : 2
}
} ]
} ],
"statements" : [ {
"kind" : "ExprStmt",
"location" : [ 32, 2, 32, 2 ],
"expr" : {
"kind" : "IntegerLiteral",
"location" : [ 32, 2, 32, 2 ],
"value" : 1
}
} ]
}, {
"kind" : "VarDef",
"location" : [ 34, 1, 34, 78 ],
"var" : {
"kind" : "TypedVar",
"location" : [ 34, 1, 34, 71 ],
"identifier" : {
"kind" : "Identifier",
"location" : [ 34, 1, 34, 2 ],
"name" : "xs"
},
"type" : {
"kind" : "ListType",
"location" : [ 34, 5, 34, 71 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 6, 34, 70 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 7, 34, 69 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 8, 34, 68 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 9, 34, 67 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 10, 34, 66 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 11, 34, 65 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 12, 34, 64 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 13, 34, 63 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 14, 34, 62 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 15, 34, 61 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 16, 34, 60 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 17, 34, 59 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 18, 34, 58 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 19, 34, 57 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 20, 34, 56 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 21, 34, 55 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 22, 34, 54 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 23, 34, 53 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 24, 34, 52 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 25, 34, 51 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 26, 34, 50 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 27, 34, 49 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 28, 34, 48 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 29, 34, 47 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 30, 34, 46 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 31, 34, 45 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 32, 34, 44 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 33, 34, 43 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 34, 34, 42 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 35, 34, 41 ],
"elementType" : {
"kind" : "ListType",
"location" : [ 34, 36, 34, 40 ],
"elementType" : {
"kind" : "ClassType",
"location" : [ 34, 37, 34, 39 ],
"className" : "int"
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
},
"value" : {
"kind" : "NoneLiteral",
"location" : [ 34, 75, 34, 78 ]
}
} ],
"statements" : [ {
"kind" : "AssignStmt",
"location" : [ 35, 1, 35, 70 ],
"targets" : [ {
"kind" : "Identifier",
"location" : [ 35, 1, 35, 2 ],
"name" : "xs"
} ],
"value" : {
"kind" : "ListExpr",
"location" : [ 35, 6, 35, 70 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 7, 35, 69 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 8, 35, 68 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 9, 35, 67 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 10, 35, 66 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 11, 35, 65 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 12, 35, 64 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 13, 35, 63 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 14, 35, 62 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 15, 35, 61 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 16, 35, 60 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 17, 35, 59 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 18, 35, 58 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 19, 35, 57 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 20, 35, 56 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 21, 35, 55 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 22, 35, 54 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 23, 35, 53 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 24, 35, 52 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 25, 35, 51 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 26, 35, 50 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 27, 35, 49 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 28, 35, 48 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 29, 35, 47 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 30, 35, 46 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 31, 35, 45 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 32, 35, 44 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 33, 35, 43 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 34, 35, 42 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 35, 35, 41 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 36, 35, 40 ],
"elements" : [ {
"kind" : "ListExpr",
"location" : [ 35, 37, 35, 39 ],
"elements" : [ {
"kind" : "IntegerLiteral",
"location" : [ 35, 38, 35, 38 ],
"value" : 1
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
} ]
}
}, {
"kind" : "IfStmt",
"location" : [ 37, 1, 46, 1 ],
"condition" : {
"kind" : "IntegerLiteral",
"location" : [ 37, 4, 37, 4 ],
"value" : 1
},
"thenBody" : [ {
"kind" : "IfStmt",
"location" : [ 38, 5, 44, 0 ],
"condition" : {
"kind" : "IntegerLiteral",
"location" : [ 38, 8, 38, 8 ],
"value" : 2
},
"thenBody" : [ {
"kind" : "IfStmt",
"location" : [ 39, 9, 44, 0 ],
"condition" : {
"kind" : "IntegerLiteral",
"location" : [ 39, 12, 39, 12 ],
"value" : 3
},
"thenBody" : [ {
"kind" : "IfStmt",
"location" : [ 40, 13, 42, 8 ],
"condition" : {
"kind" : "IntegerLiteral",
"location" : [ 40, 16, 40, 16 ],
"value" : 4
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 41, 17, 41, 20 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 41, 17, 41, 20 ],
"value" : true
}
} ],
"elseBody" : [ ]
} ],
"elseBody" : [ {
"kind" : "IfStmt",
"location" : [ 42, 9, 44, 0 ],
"condition" : {
"kind" : "UnaryExpr",
"location" : [ 42, 14, 42, 15 ],
"operator" : "-",
"operand" : {
"kind" : "IntegerLiteral",
"location" : [ 42, 15, 42, 15 ],
"value" : 3
}
},
"thenBody" : [ {
"kind" : "ExprStmt",
"location" : [ 43, 13, 43, 17 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 43, 13, 43, 17 ],
"value" : false
}
} ],
"elseBody" : [ ]
} ]
} ],
"elseBody" : [ ]
} ],
"elseBody" : [ {
"kind" : "ExprStmt",
"location" : [ 45, 5, 45, 9 ],
"expr" : {
"kind" : "BooleanLiteral",
"location" : [ 45, 5, 45, 9 ],
"value" : false
}
} ]
} ],
"errors" : {
"errors" : [ ],
"kind" : "Errors",
"location" : [ 0, 0, 0, 0 ]
}
}

23
pa1-tests/run-tests.sh
Unescape View File

@ -0,0 +1,23 @@
#!/usr/bin/env bash
set -o errexit
set -o nounset
set -o pipefail
JAVA="java -cp pa1-tests/chocopy-ref.jar:target/assignment.jar chocopy.ChocoPy"
echo "# CORE TESTS"
${JAVA} --pass=s --test --dir pa1-tests/core
echo
echo "# EXTRA TESTS"
${JAVA} --pass=s --test --dir pa1-tests/extra
echo
echo "# STUDENT TESTS"
function regen_ast_and_test {
${JAVA} --pass=r "${1}" --out "${1}.ast" 2>/dev/null 1>&2
${JAVA} --pass=s --test "${1}"
}
regen_ast_and_test src/test/data/pa1/student_contributed/good.py
regen_ast_and_test src/test/data/pa1/student_contributed/bad.py

516
src/main/cup/chocopy/pa1/ChocoPy.cup
Unescape View File

@ -0,0 +1,516 @@
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java_cup.runtime.*;
import chocopy.common.astnodes.*;
/* The following code section is copied verbatim to the generated
* parser class. */
parser code {:
/* The following fields and methods deal with error reporting
* Avoid changing these unless you know what you are doing. */
/** Node that accumulates error messages to be added to the Program
* node produced as a result. */
public final Errors errors = new Errors(new ArrayList<>());
/** Return the Program node that results from parsing the stream of
* tokens produced by lexical analysis. In the case of syntax errors,
* the program may be empty, but will have error messages. */
public Program parseProgram(boolean debug) {
try {
Symbol result = debug ? debug_parse() : parse();
if (result == null || !(result.value instanceof Program)) {
return new Program(new Location(0, 0), new Location(0, 0),
new ArrayList<Declaration>(),
new ArrayList<Stmt>(),
errors);
} else {
return (Program) result.value;
}
} catch (RuntimeException excp) {
throw excp;
} catch (Exception excp) {
String msg =
String.format("Internal parser error detected: %s%n", excp);
throw new AssertionError(msg);
}
}
@Override
public SymbolFactory getSymbolFactory() {
return ((ChocoPyLexer) getScanner()).symbolFactory;
}
@Override
public void syntax_error(Symbol cur_token) {
String token = symbl_name_from_id(cur_token.sym);
String text = ((ChocoPyLexer) getScanner()).yytext();
errors.syntaxError(
((ComplexSymbolFactory.ComplexSymbol) cur_token).xleft,
((ComplexSymbolFactory.ComplexSymbol) cur_token).xright,
"Parse error near token %s: %s", token, text);
}
@Override
public void unrecovered_syntax_error(Symbol cur_token) {
/* Do not die */
}
:}
/**************************************************************************
* FEEL FREE TO MODIFY ANYTHING BELOW THIS LINE
*
* The rules provided below parse expressions of the form <INT> + <INT> + ...
* You can re-use these rules or edit them as you wish. The start rule
* should return a node of type Program.
*
* Tips: Production rules are usually followed by action code that will be
* copied to the generated parser to be executed immediately after a reduce
* operation; that is, when a production rule has been matched. You can name
* a nonterminal or terminal symbol in a production rule using the colon
* notation, e.g. expr_stmt ::= expr:e, to get the AST node for the matched
* expression. In the action code, `e` will be a variable of whatever type
* has been declared for the corresponding nonterminal, such as `Expr`.
* Therefore, you can construct an AST Node of type `ExprStmt` with `e` in the
* constructor: `new ExprStmt(exleft, exright, e)`
*
* The variables `exleft` and `exright` are automatically generated by CUP
* and contain Location objects for the start and end of the expression `e`.
* You can collect start and line number info for AST nodes by taking the
* location of the left end of the leftmost symbol in a rule and the
* location of the right end of the rightmost symbol. The auto-generated
* variables have names `<sym>xleft` and `<sym>xright`, where <sym> is the
* name given to the symbol using the colon notation.
*
* When you have nonterminals that are lists of things, e.g. List<Stmt> or
* List<Declaration>, it is helpful to get the leftmost and rightmost
* source location from within this list; we have provided some utility
* functions below to do just that.
**************************************************************************/
/* The following code section is copied verbatim to the class that performs
* production-rule actions. */
action code {:
/** Return a mutable list initially containing the single value ITEM. */
<T> List<T> single(T item) {
List<T> list = new ArrayList<>();
if (item != null) {
list.add(item);
}
return list;
}
/** If ITEM is non-null, appends it to the end of LIST. Then returns
* LIST. */
<T> List<T> combine(List<T> list, T item) {
if (item != null) {
list.add(item);
}
return list;
}
<T> List<T> combine(List<T> list, List<T> item) {
if (item != null) {
Iterator<T> it = item.iterator();
while(it.hasNext())
list.add(it.next());
}
return list;
}
/** Return a mutable empty list. */
<T> List<T> empty() {
return new ArrayList<T>();
}
class FuncBody {
public List<Declaration> fbd;
public List<Stmt> sl;
public FuncBody(List<Declaration> fbd, List<Stmt> sl){
this.fbd = fbd;
this.sl = sl;
}
}
/** Return the leftmost non-whitespace location in NODES, or null if NODES
* is empty. Assumes that the nodes of NODES are ordered in increasing
* order of location, from left to right. */
ComplexSymbolFactory.Location getLeft(List<? extends Node> nodes) {
if (nodes.isEmpty()) {
return null;
}
Node first = nodes.get(0);
return new ComplexSymbolFactory.Location(first.getLocation()[0],
first.getLocation()[1]);
}
/** Return the rightmost non-whitespace location in NODES, or null if NODES
* is empty. Assumes that the nodes of NODES are ordered in increasing
* order of location, from left to right. */
ComplexSymbolFactory.Location getRight(List<? extends Node> nodes) {
if (nodes.isEmpty()) {
return null;
}
Node last = nodes.get(nodes.size()-1);
return new ComplexSymbolFactory.Location(last.getLocation()[2],
last.getLocation()[3]);
}
:}
/* Terminal symbols (tokens returned by the lexer). The declaration
* terminal <identifier1>, <identifier2>, ...;
* declares each <identifieri> as the denotation of a distinct type terminal
* symbol for use in the grammar. The declaration
* terminal <type> <identifier1>, ...;
* does the same, and in addition indicates that the lexer supplies a
* semantic value of type <type> for these symbols that may be referenced
* in actions ( {: ... :} ).
*/
terminal INDENT;
terminal DEDENT;
terminal String ID;
terminal String STRING;
/* Terminal Delimiters */
terminal NEWLINE;
terminal String COLON;
terminal String COMMA;
/* Terminal Literals */
terminal Integer NUMBER;
terminal Boolean BOOL;
terminal String NONE;
/* Terminal Keywords */
terminal String IF;
terminal String ELSE;
terminal String ELIF;
terminal String WHILE;
terminal String CLASS;
terminal String DEF;
terminal String LAMBDA;
terminal String AS;
terminal String FOR;
terminal String GLOBAL;
terminal String IN;
terminal String NONLOCAL;
terminal String PASS;
terminal String RETURN;
terminal String ASSERT;
terminal String AWAIT;
terminal String BREAK;
terminal String CONTINUE;
terminal String DEL;
terminal String EXCEPT;
terminal String FINALLY;
terminal String FROM;
terminal String IMPORT;
terminal String RAISE;
terminal String TRY;
terminal String WITH;
terminal String YIELD;
/* Terminal Operators */
terminal String PLUS;
terminal String MINUS;
terminal String MUL;
terminal String DIV;
terminal String MOD;
terminal String GT;
terminal String LT;
terminal String EQUAL;
terminal String NEQ;
terminal String GEQ;
terminal String LEQ;
terminal String ASSIGN;
terminal String AND;
terminal String OR;
terminal String NOT;
terminal String DOT;
terminal String LPAR;
terminal String RPAR;
terminal String LBR;
terminal String RBR;
terminal String ARROW;
terminal String IS;
terminal String UMINUS;
/* Returned by the lexer for erroneous tokens. Since it does not appear in
* the grammar, it indicates a syntax error. */
terminal String UNRECOGNIZED;
/* Nonterminal symbols (defined in production rules below).
* As for terminal symbols,
* non terminal <type> <identifier1>, ..., <identifiern>;
* defines the listed nonterminal identifier symbols to have semantic values
* of type <type>. */
non terminal Program program;
non terminal List<Declaration> defs, program_head, opt_program_head, class_body, class_body_defs, fun_body_decs;
non terminal List<Stmt> stmt_list, opt_stmt_list, block, else_body;
non terminal Stmt stmt, simple_stmt;
non terminal Expr expr, pexpr, cexpr;
non terminal VarDef var_def;
non terminal ClassDef class_def;
non terminal FuncDef fun_def;
non terminal Literal literal;
non terminal StringLiteral bin_op, comp_op;
non terminal TypedVar typed_var;
non terminal TypeAnnotation type, ret_type;
non terminal Identifier identifier;
non terminal List<TypedVar> typed_vars;
non terminal GlobalDecl global_decl;
non terminal NonLocalDecl nonlocal_decl;
non terminal List<Expr> opt_target, expr_list;
non terminal Expr target;
non terminal MemberExpr member_expr;
non terminal IndexExpr index_expr;
non terminal FuncBody fun_body;
/* Precedences (lowest to highest) for resolving what would otherwise be
* ambiguities in the form of shift/reduce conflicts.. */
precedence left OR;
precedence left AND;
precedence left NOT;
precedence nonassoc EQUAL, NEQ, LT, GT, LEQ, GEQ, IS;
precedence left PLUS, MINUS;
precedence left MUL, DIV, MOD;
precedence left UMINUS;
precedence left DOT, COMMA, LBR, RBR;
precedence right IF, ELSE;
/* The start symbol. */
start with program;
/***** GRAMMAR RULES *****/
/* Rules are defined in the order given by the language reference */
/* program */
program ::= program_head:d opt_stmt_list:s
{:
ComplexSymbolFactory.Location left = d.isEmpty() ? getLeft(s) : getLeft(d);
if(left == null)
left = new ComplexSymbolFactory.Location(1,1);
RESULT = new Program(left, sxright, d, s, errors);
:}
;
program_head ::= program_head:d var_def:vd {: RESULT = combine(d, vd); :}
| program_head:d class_def:cd {: RESULT = combine(d, cd); :}
| program_head:d fun_def:fd {: RESULT = combine(d, fd); :}
| program_head:d error:e {: RESULT = d; :}
| {: RESULT = empty(); :}
;
opt_stmt_list ::= {: RESULT = empty(); :}
| stmt_list:s {: RESULT = s; :}
;
/* class_def */
class_def ::= CLASS:c identifier:id LPAR identifier:parentId RPAR COLON NEWLINE INDENT class_body:cb DEDENT {: RESULT = new ClassDef(cxleft, getRight(cb), id, parentId, cb); :};
/* class_body */
class_body ::= PASS NEWLINE {: RESULT = empty(); :}
| class_body_defs:defs {: RESULT = defs; :}
;
class_body_defs ::= class_body_defs:defs var_def:vd {: RESULT = combine(defs, vd); :}
| class_body_defs:defs fun_def:fd {: RESULT = combine(defs, fd); :}
| class_body_defs:defs error {: RESULT = defs; :}
| var_def:vd {: RESULT = single(vd); :}
| fun_def:fd {: RESULT = single(fd); :}
;
/* fun_def */
fun_def ::= DEF:def identifier:id LPAR typed_vars:params RPAR ret_type:rt COLON:col NEWLINE INDENT fun_body_decs:fbd stmt_list:sl DEDENT
{: TypeAnnotation _rt = rt;if((rt instanceof ClassType) && ((ClassType)rt).className == "<None>") _rt = new ClassType( colxright, colxright, "<None>");RESULT = new FuncDef(defxleft, getRight(sl), id, params, _rt, fbd, sl); :}
;
ret_type ::= ARROW type:t {: RESULT= t; :}
| {: RESULT= new ClassType(null, null,"<None>"); :}
;
typed_vars ::= typed_var:tv {: RESULT= single(tv); :}
| typed_vars:tvs COMMA typed_var:tv {: RESULT= combine(tvs, tv); :}
| typed_vars:tvs COMMA error {: RESULT= tvs; :}
| {: RESULT= empty(); :}
;
/* fun_body */
fun_body ::= fun_body_decs:fbd stmt_list:sl {: RESULT = new FuncBody(fbd, sl);:}
| fun_body_decs:fbd {: RESULT = new FuncBody(fbd, new ArrayList<Stmt>());:}
;
fun_body_decs ::= fun_body_decs:fbd global_decl:gd {: RESULT= combine(fbd, gd); :}
| fun_body_decs:fbd nonlocal_decl:nd {: RESULT= combine(fbd, nd); :}
| fun_body_decs:fbd var_def:vd {: RESULT= combine(fbd, vd); :}
| fun_body_decs:fbd fun_def:fd {: RESULT= combine(fbd, fd); :}
| fun_body_decs:fbd error {: RESULT= fbd; :}
| {: RESULT= empty(); :}
;
/* typed_var */
typed_var ::= identifier:id COLON type:t {: RESULT = new TypedVar(idxleft, txright, id, t); :};
/* type */
type ::= identifier:id {: RESULT = new ClassType(idxleft, idxright, id.name); :}
| STRING:str {: RESULT = new ClassType(strxleft, strxright, str); :}
| LBR:lbr type:t RBR:rbr {: RESULT = new ListType(lbrxleft, rbrxright, t); :}
;
/* global_decl */
global_decl ::= GLOBAL:g identifier:id NEWLINE {: RESULT = new GlobalDecl(gxleft, idxright, id); :};
/* nonlocal_decl */
nonlocal_decl ::= NONLOCAL:n identifier:id NEWLINE {: RESULT = new NonLocalDecl(nxleft, idxright, id); :};
/* var_def */
var_def ::= typed_var:t ASSIGN literal:l NEWLINE {: RESULT = new VarDef(txleft, lxright, t, l); :};
/* stmt */
stmt ::= simple_stmt:s NEWLINE {: RESULT = s; :}
| IF:i expr:cond COLON block:b else_body:elb {: RESULT = new IfStmt(ixleft, getRight(elb), cond, b, elb); :}
| WHILE:wh expr:cond COLON block:b {: RESULT = new WhileStmt(whxleft, getRight(b), cond, b); :}
| FOR:f identifier:id IN expr:e COLON block:b {: RESULT = new ForStmt(fxleft, getRight(b), id, e, b); :}
;
else_body ::= ELSE:el COLON block:b {: RESULT = b; :}
| ELIF:el expr:cond COLON block:b else_body:elb {: RESULT = single(new IfStmt(elxleft, getRight(elb), cond, b, elb)); :}
| {: RESULT = empty(); :}
;
/* simple_stmt */
simple_stmt ::= PASS:p {: RESULT = null; :}
| expr:e {: RESULT = new ExprStmt(exleft, exright, e); :}
| RETURN:r expr:e {: RESULT = new ReturnStmt(rxleft, exright, e); :}
| RETURN:r {: RESULT = new ReturnStmt(rxleft, rxright, null); :}
| opt_target:ot expr:e {: RESULT = new AssignStmt(getLeft(ot), exright, ot, e); :}
;
opt_target ::= opt_target:ot target:t ASSIGN {: RESULT = combine(ot, t); :}
| target:t ASSIGN {: RESULT = single(t); :}
;
/* block */
block ::= NEWLINE INDENT stmt_list:sl DEDENT {: RESULT = sl; :};
/* literal */
literal ::= NONE:n {: RESULT = new NoneLiteral(nxleft, nxright); :}
| BOOL:b {: RESULT = new BooleanLiteral(bxleft, bxright, b); :}
| NUMBER:n {: RESULT = new IntegerLiteral(nxleft, nxright, n); :}
| STRING:s {: RESULT = new StringLiteral(sxleft, sxright, s); :}
;
/* expr */
expr ::= cexpr:ce {: RESULT = ce; :}
| NOT:n expr:exp {: RESULT = new UnaryExpr(nxleft, expxright, n, exp); :}
| expr:e1 AND:a expr:e2 {: RESULT = new BinaryExpr(e1xleft, e2xright, e1, a, e2); :}
| expr:e1 OR:o expr:e2 {: RESULT = new BinaryExpr(e1xleft, e2xright, e1, o, e2); :}
| expr:e1 IF expr:e2 ELSE expr:e3 {: RESULT = new IfExpr(e1xleft, e3xright, e2, e1, e3); :}
;
/* cexpr */
cexpr ::= pexpr:pe {: RESULT = pe; :}
| pexpr:p1 comp_op:co cexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, co.value, p2); :}
;
/* pexpr */
pexpr ::= identifier:id {: RESULT = id; :}
| literal:l {: RESULT = l; :}
| LBR:lbr expr_list:l RBR:rbr {: RESULT = new ListExpr(lbrxleft, rbrxright, l); :}
| LPAR:lpar expr:e RPAR:rpar {: RESULT = e; :}
| member_expr:m {: RESULT = m; :}
| index_expr:i {: RESULT = i; :}
| member_expr:m LPAR expr_list:l RPAR:rpar {: RESULT = new MethodCallExpr(mxleft, rparxright, m, l); :}
| identifier:id LPAR expr_list:l RPAR:rpar {: RESULT = new CallExpr(idxleft, rparxright, id, l); :}
| pexpr:p1 PLUS:bo pexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, bo, p2); :}
| pexpr:p1 MINUS:bo pexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, bo, p2); :}
| pexpr:p1 MUL:bo pexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, bo, p2); :}
| pexpr:p1 DIV:bo pexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, bo, p2); :}
| pexpr:p1 MOD:bo pexpr:p2 {: RESULT = new BinaryExpr(p1xleft, p2xright, p1, bo, p2); :}
| MINUS:m pexpr:p {: RESULT = new UnaryExpr(mxleft, pxright, m, p); :} %prec UMINUS
;
expr_list ::= expr:e {: RESULT = single(e); :}
| expr_list:el COMMA expr:e {: RESULT = combine(el, e); :}
| {: RESULT = new ArrayList<Expr>(); :}
;
/* bin_op */ //We may still be able to use bin_op, so I left it here.
bin_op ::= PLUS:a {: RESULT = new StringLiteral(axleft, axright, "+"); :}
| MINUS:a {: RESULT = new StringLiteral(axleft, axright, "-"); :}
| MUL:a {: RESULT = new StringLiteral(axleft, axright, "*"); :}
| DIV:a {: RESULT = new StringLiteral(axleft, axright, "//"); :} //Section 2.6.3 in chocopy language reference
| MOD:a {: RESULT = new StringLiteral(axleft, axright, "%"); :}
;
/* comp_op */ //this might also need some change in order not to break left associativity
comp_op ::= EQUAL:a {: RESULT = new StringLiteral(axleft, axright, "=="); :}
| NEQ:a {: RESULT = new StringLiteral(axleft, axright, "!="); :}
| LEQ:a {: RESULT = new StringLiteral(axleft, axright, "<="); :}
| GEQ:a {: RESULT = new StringLiteral(axleft, axright, ">="); :}
| LT:a {: RESULT = new StringLiteral(axleft, axright, "<"); :}
| GT:a {: RESULT = new StringLiteral(axleft, axright, ">"); :}
| IS:a {: RESULT = new StringLiteral(axleft, axright, "is"); :}
;
/* member_expr */
member_expr ::= pexpr:p DOT identifier:id {: RESULT = new MemberExpr(pxleft, idxright, p, id); :}
;
/* index_expr */
index_expr ::= pexpr:p LBR expr:e RBR:rbr {: RESULT = new IndexExpr(pxleft, rbrxright, p, e); :}
;
/* target */
target ::= identifier:id {: RESULT = id; :}
| member_expr:m {: RESULT = m; :}
| index_expr:i {: RESULT = i; :}
;
/* Extras - rules below have not been given in language reference, we have them to ease implementation */
identifier ::= ID:idStr {: RESULT = new Identifier(idStrxleft, idStrxright, idStr); :};
stmt_list ::= stmt:s {: RESULT = single(s); :}
| stmt_list:l stmt:s {: RESULT = combine(l, s); :}
| stmt_list:l error {: RESULT = l; :}
/* If there is a syntax error in the source, this says to discard
* symbols from the parsing stack and perform reductions until
* there is a stmt_list on top of the stack, and then to discard
* input symbols until it is possible to shift again, reporting
* a syntax error. */
;

1
src/main/java/chocopy/common/Utils.java
Unescape View File

@ -6,6 +6,7 @@ import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.stream.Collectors; import java.util.stream.Collectors;
/** Utility functions for general use. */ /** Utility functions for general use. */
public class Utils { public class Utils {

23
src/main/java/chocopy/common/analysis/NodeAnalyzer.java
Unescape View File

@ -19,6 +19,29 @@ import chocopy.common.astnodes.*;
* <p>The class AbstractNodeAnalyzer provides empty default implementations for these methods. * <p>The class AbstractNodeAnalyzer provides empty default implementations for these methods.
* *
* <p>The type T is the type of result returned by the encapsulated analysis. * <p>The type T is the type of result returned by the encapsulated analysis.
=======
* This interface can be used to separate logic for various concrete
* classes in the AST class hierarchy.
* <p>
* The idea is that a phase of the analysis is encapsulated in a class
* that implements this interface, and contains an overriding of the
* analyze method for each concrete Node class that needs something
* other than default processing. Each concrete node class, C, implements
* a generic dispatch method that takes a NodeAnalyzer<T> argument and
* calls the overloading of analyze that takes an argument of type C.
* The effect is that anode.dispatch(anAnalyzer) executes the method
* anAnalyzer.analyze that is appropriate to aNode's dynamic type.
* As a result each NodeAnalyzer subtype encapsulates all
* implementations of a particular action on Nodes. Thus, it inverts
* the usual OO pattern in which the implementations of analysis A for
* each different class are scattered among the class bodies
* themselves as overridings of a method A on the Node class.
* <p>
* The class AbstractNodeAnalyzer provides empty default
* implementations for these methods.
* <p>
* The type T is the type of result returned by the encapsulated analysis.
>>>>>>> pa1/master
*/ */
public interface NodeAnalyzer<T> { public interface NodeAnalyzer<T> {

1
src/main/java/chocopy/common/astnodes/AssignStmt.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** Single and multiple assignments. */ /** Single and multiple assignments. */
public class AssignStmt extends Stmt { public class AssignStmt extends Stmt {
/** List of left-hand sides. */ /** List of left-hand sides. */

1
src/main/java/chocopy/common/astnodes/BinaryExpr.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** <operand> <operator> <operand>. */ /** <operand> <operator> <operand>. */
public class BinaryExpr extends Expr { public class BinaryExpr extends Expr {

1
src/main/java/chocopy/common/astnodes/BooleanLiteral.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Literals True or False. */ /** Literals True or False. */
public final class BooleanLiteral extends Literal { public final class BooleanLiteral extends Literal {

1
src/main/java/chocopy/common/astnodes/CallExpr.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** A function call. */ /** A function call. */
public class CallExpr extends Expr { public class CallExpr extends Expr {

1
src/main/java/chocopy/common/astnodes/ClassDef.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** A class definition. */ /** A class definition. */
public class ClassDef extends Declaration { public class ClassDef extends Declaration {

1
src/main/java/chocopy/common/astnodes/ClassType.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** A simple class type name. */ /** A simple class type name. */
public final class ClassType extends TypeAnnotation { public final class ClassType extends TypeAnnotation {

2
src/main/java/chocopy/common/astnodes/CompilerError.java
Unescape View File

@ -7,6 +7,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.Arrays; import java.util.Arrays;
import java.util.Objects; import java.util.Objects;
/** Represents a single error. Does not correspond to any Python source construct. */ /** Represents a single error. Does not correspond to any Python source construct. */
public class CompilerError extends Node { public class CompilerError extends Node {
@ -49,6 +50,7 @@ public class CompilerError extends Node {
return analyzer.analyze(this); return analyzer.analyze(this);
} }
/** The error message. */ /** The error message. */
public final String message; public final String message;
/** True if this is a syntax error. */ /** True if this is a syntax error. */

2
src/main/java/chocopy/common/astnodes/Declaration.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonIgnore;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Base of all AST nodes representing definitions or declarations. */ /** Base of all AST nodes representing definitions or declarations. */
public abstract class Declaration extends Node { public abstract class Declaration extends Node {
@ -11,6 +12,7 @@ public abstract class Declaration extends Node {
super(left, right); super(left, right);
} }
/** Return the identifier defined by this Declaration. */ /** Return the identifier defined by this Declaration. */
@JsonIgnore @JsonIgnore
public abstract Identifier getIdentifier(); public abstract Identifier getIdentifier();

3
src/main/java/chocopy/common/astnodes/Errors.java
Unescape View File

@ -7,6 +7,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** Collects the error messages in a Program. There is exactly one per Program node. */ /** Collects the error messages in a Program. There is exactly one per Program node. */
public class Errors extends Node { public class Errors extends Node {
@ -26,11 +27,13 @@ public class Errors extends Node {
allowMultipleErrors = true; allowMultipleErrors = true;
} }
/** Return true iff there are any errors. */ /** Return true iff there are any errors. */
public boolean hasErrors() { public boolean hasErrors() {
return !this.errors.isEmpty(); return !this.errors.isEmpty();
} }
/** Prevent multiple semantic errors on the same node. */ /** Prevent multiple semantic errors on the same node. */
public void suppressMultipleErrors() { public void suppressMultipleErrors() {
allowMultipleErrors = false; allowMultipleErrors = false;

1
src/main/java/chocopy/common/astnodes/Expr.java
Unescape View File

@ -1,5 +1,6 @@
package chocopy.common.astnodes; package chocopy.common.astnodes;
import chocopy.common.analysis.types.Type; import chocopy.common.analysis.types.Type;
import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonInclude;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;

1
src/main/java/chocopy/common/astnodes/ExprStmt.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Statements consisting of expressions. */ /** Statements consisting of expressions. */
public final class ExprStmt extends Stmt { public final class ExprStmt extends Stmt {

1
src/main/java/chocopy/common/astnodes/ForStmt.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** For statements. */ /** For statements. */
public class ForStmt extends Stmt { public class ForStmt extends Stmt {
/** Control variable. */ /** Control variable. */

1
src/main/java/chocopy/common/astnodes/FuncDef.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** Def statements. */ /** Def statements. */
public class FuncDef extends Declaration { public class FuncDef extends Declaration {

1
src/main/java/chocopy/common/astnodes/GlobalDecl.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Declaration of global variable. */ /** Declaration of global variable. */
public class GlobalDecl extends Declaration { public class GlobalDecl extends Declaration {

1
src/main/java/chocopy/common/astnodes/Identifier.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** A simple identifier. */ /** A simple identifier. */
public class Identifier extends Expr { public class Identifier extends Expr {

1
src/main/java/chocopy/common/astnodes/IfExpr.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Conditional expressions. */ /** Conditional expressions. */
public class IfExpr extends Expr { public class IfExpr extends Expr {
/** Boolean condition. */ /** Boolean condition. */

1
src/main/java/chocopy/common/astnodes/IfStmt.java
Unescape View File

@ -5,6 +5,7 @@ import java_cup.runtime.ComplexSymbolFactory.Location;
import java.util.List; import java.util.List;
/** Conditional statement. */ /** Conditional statement. */
public class IfStmt extends Stmt { public class IfStmt extends Stmt {
/** Test condition. */ /** Test condition. */

1
src/main/java/chocopy/common/astnodes/IndexExpr.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** List-indexing expression. */ /** List-indexing expression. */
public class IndexExpr extends Expr { public class IndexExpr extends Expr {

1
src/main/java/chocopy/common/astnodes/IntegerLiteral.java
Unescape View File

@ -3,6 +3,7 @@ package chocopy.common.astnodes;
import chocopy.common.analysis.NodeAnalyzer; import chocopy.common.analysis.NodeAnalyzer;
import java_cup.runtime.ComplexSymbolFactory.Location; import java_cup.runtime.ComplexSymbolFactory.Location;
/** Integer numerals. */ /** Integer numerals. */
public final class IntegerLiteral extends Literal { public final class IntegerLiteral extends Literal {

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save