Handle syntax errors in parser (#48)

Author: gf712

integration/program.cpp

@@ -110,7 +110,7 @@ class RunPythonProgram : public ::testing::Test
 
 		auto lexer = Lexer::create(std::string(program), "_integration_dummy_.py");
 		parser::Parser p{ lexer };
-		p.parse();
+		ASSERT_TRUE(p.parse().is_ok());
 		p.module()->print_node("");
 		m_bytecode = compiler::compile(p.module(),
 			{},

integration/run_python_tests.sh

@@ -46,4 +46,38 @@ else
     echo $file "... PASSED!"
 fi
 
+# A syntax error must exit non-zero and report the line the parser actually gave
+# up on -- not line 1 -- with a caret under the offending token.
+file=$SCRIPT_DIR/tests/expected_failures/syntax_error_reporting.py
+output=$(timeout 10s $PYTHON_EXECUTABLE $file --gc-frequency $GC_FREQUENCY 2>&1)
+if [ $? -eq 0 ]; then
+    echo $file "... FAILED! (expected a non-zero exit code)"
+    exit_code=1
+elif ! echo "$output" | grep -q '", line 4$'; then
+    echo $file "... FAILED! (expected the error on line 4, got: ${output})"
+    exit_code=1
+elif ! echo "$output" | grep -qF '            ^'; then
+    echo $file "... FAILED! (expected a caret under the ':', got: ${output})"
+    exit_code=1
+elif ! echo "$output" | grep -q '^SyntaxError: invalid syntax$'; then
+    echo $file "... FAILED! (expected a SyntaxError, got: ${output})"
+    exit_code=1
+else
+    echo $file "... PASSED!"
+fi
+
+# Running off the end of the input puts the caret just past the last character.
+file=$SCRIPT_DIR/tests/expected_failures/syntax_error_end_of_line.py
+output=$(timeout 10s $PYTHON_EXECUTABLE $file --gc-frequency $GC_FREQUENCY 2>&1)
+if [ $? -eq 0 ]; then
+    echo $file "... FAILED! (expected a non-zero exit code)"
+    exit_code=1
+elif ! echo "$output" | grep -qxF '          ^'; then
+    echo $file "... FAILED! (expected a caret after the ',', got: ${output})"
+    exit_code=1
+else
+    echo $file "... PASSED!"
+fi
+
+
 exit $exit_code

integration/tests/expected_failures/syntax_error_end_of_line.py

@@ -0,0 +1,2 @@
+x = 1
+foo(1,

integration/tests/expected_failures/syntax_error_reporting.py

@@ -0,0 +1,5 @@
+x = 1
+y = 2
+
+def foo(:
+    pass

integration/tests/syntax_error_attributes.py

@@ -0,0 +1,60 @@
+# SyntaxError carries CPython's (msg, filename, lineno, offset, text) attribute
+# set, and the two-argument form is what both Python code and the parser use.
+e = SyntaxError("invalid syntax", ("bad.py", 5, 9, "def foo(:"))
+assert e.args == ("invalid syntax", ("bad.py", 5, 9, "def foo(:")), e.args
+assert e.msg == "invalid syntax", e.msg
+assert e.filename == "bad.py", e.filename
+assert e.lineno == 5, e.lineno
+assert e.offset == 9, e.offset
+assert e.text == "def foo(:", e.text
+assert str(e) == "invalid syntax (bad.py, line 5)", str(e)
+
+# Without an info tuple the location attributes stay None and str() is the message.
+bare = SyntaxError("boom")
+assert bare.args == ("boom",), bare.args
+assert bare.msg == "boom", bare.msg
+assert bare.filename is None, bare.filename
+assert bare.lineno is None, bare.lineno
+assert bare.offset is None, bare.offset
+assert bare.text is None, bare.text
+assert str(bare) == "boom", str(bare)
+
+# With no arguments at all every attribute, msg included, is None.
+empty = SyntaxError()
+assert empty.msg is None, empty.msg
+assert empty.filename is None, empty.filename
+assert empty.lineno is None, empty.lineno
+assert empty.offset is None, empty.offset
+assert empty.text is None, empty.text
+
+# Python 3.9 reports a short info tuple as an IndexError.
+try:
+    SyntaxError("x", ("f.py", 1))
+    assert False, "expected IndexError"
+except IndexError as error:
+    assert str(error) == "tuple index out of range", str(error)
+
+try:
+    SyntaxError("x", foo=1)
+    assert False, "expected TypeError"
+except TypeError as error:
+    assert str(error) == "SyntaxError() takes no keyword arguments", str(error)
+
+# The attributes are writable, so nothing may assume their type.
+e.lineno = "not an int"
+assert str(e) == "invalid syntax (bad.py)", str(e)
+
+# compile() raises the parser's SyntaxError instead of aborting.
+try:
+    compile("def foo(:", "<string>", "exec")
+    assert False, "expected SyntaxError"
+except SyntaxError as error:
+    assert error.msg == "invalid syntax", error.msg
+    assert error.lineno == 1, error.lineno
+    assert error.offset == 9, error.offset
+
+# lineno is user-supplied, so out-of-range values are printed, not asserted on.
+negative = SyntaxError("m", ("f.py", -1, 1, "code"))
+assert str(negative) == "m (f.py, line -1)", str(negative)
+huge = SyntaxError("m", ("f.py", 10**30, 1, "code"))
+assert str(huge) == "m (f.py, line 1000000000000000000000000000000)", str(huge)

src/ast/optimizers/Optimizers_tests.cpp

@@ -466,7 +466,7 @@ void assert_generates_ast(std::string_view program,
 	parser::Parser p{ lexer };
 	const auto spdlog_level = spdlog::get_level();
 	spdlog::set_level(spdlog::level::debug);
-	p.parse();
+	ASSERT(p.parse().is_ok());
 	spdlog::set_level(spdlog_level);
 
 	if (lvl > compiler::OptimizationLevel::None) {

src/executable/bytecode/BytecodeProgram_tests.cpp

@@ -14,7 +14,7 @@ std::shared_ptr<BytecodeProgram> generate_bytecode(std::string_view program)
 {
 	auto lexer = Lexer::create(std::string(program), "_bytecode_program_tests_.py");
 	parser::Parser p{ lexer };
-	p.parse();
+	ASSERT(p.parse().is_ok());
 
 	auto module = p.module();
 	ASSERT(module);

src/executable/bytecode/codegen/BytecodeGenerator_tests.cpp

@@ -15,7 +15,7 @@ std::shared_ptr<BytecodeProgram> generate_bytecode(std::string_view program)
 {
 	auto lexer = Lexer::create(std::string(program), "_bytecode_generator_tests_.py");
 	parser::Parser p{ lexer };
-	p.parse();
+	ASSERT(p.parse().is_ok());
 
 	auto module = p.module();
 	ASSERT(module);

src/executable/bytecode/codegen/VariablesResolver_tests.cpp

@@ -13,7 +13,7 @@ VariablesResolver::VisibilityMap generate_resolver(std::string_view program)
 {
 	auto lexer = Lexer::create(std::string(program), "_bytecode_generator_tests_.py");
 	parser::Parser p{ lexer };
-	p.parse();
+	ASSERT(p.parse().is_ok());
 
 	auto *module = as<ast::Module>(p.module().get());
 	ASSERT(module);

src/executable/llvm/LLVMGenerator_tests.cpp

@@ -14,7 +14,7 @@ std::shared_ptr<Program> generate_llvm_module(std::string_view program)
 {
 	auto lexer = Lexer::create(std::string(program), "_llvm_backend_tests_.py");
 	parser::Parser p{ lexer };
-	p.parse();
+	ASSERT(p.parse().is_ok());
 
 	auto module = as<ast::Module>(p.module());
 	ASSERT(module);