add support of break statement

Author: BaLiKfromUA

pylox/interpreter.py

@@ -9,6 +9,10 @@
 from pylox.stmt import Stmt, StmtVisitor
 
 
+class BreakException(RuntimeError):
+    pass
+
+
 class Interpreter(ExprVisitor, StmtVisitor):
     def __init__(self):
         self.environment = Environment()
@@ -35,11 +39,17 @@ def visit_if_stmt(self, stmt: stmt_ast.If) -> typing.Any:
         return None
 
     def visit_while_stmt(self, stmt: stmt_ast.While) -> typing.Any:
-        while self.is_truthy(self.evaluate(stmt.condition)):
-            self.execute(stmt.body)
+        try:
+            while self.is_truthy(self.evaluate(stmt.condition)):
+                self.execute(stmt.body)
+        except BreakException:
+            pass  # Do nothing.
 
         return None
 
+    def visit_break_stmt(self, stmt) -> typing.Any:
+        raise BreakException()
+
     def visit_block_stmt(self, stmt: stmt_ast.Block) -> typing.Any:
         self.execute_block(stmt.statements, Environment(self.environment))
         return None
@@ -206,4 +216,10 @@ def stringify(value: typing.Any) -> str:
 
     @staticmethod
     def equals(left: typing.Any, right: typing.Any) -> bool:
-        return type(left) == type(right) and left == right
+        try:
+            Interpreter.check_number_operands(
+                Token(TokenType.EQUAL_EQUAL, "", "", -1), left, right
+            )
+            return left == right
+        except LoxRuntimeError:
+            return type(left) == type(right) and left == right

pylox/parser.py

@@ -19,6 +19,7 @@ def __init__(
         self.report_error = report_error
         self.allow_expressions = False
         self.found_expression = False
+        self.loop_depth = 0
 
     # program        → declaration * EOF;
     def parse(self) -> list[Stmt]:
@@ -113,6 +114,8 @@ def synchronize(self) -> None:
                 return
             elif self.peek().token_type == TokenType.RETURN:
                 return
+            elif self.peek().token_type == TokenType.BREAK:
+                return
             self.advance()
 
     # statements
@@ -149,6 +152,7 @@ def var_declaration(self) -> Stmt:
     # | printStmt
     # | whileStmt
     # | block;
+    # | break;
     def statement(self) -> Stmt:
         if self.match(TokenType.IF):
             return self.if_statement()
@@ -160,17 +164,32 @@ def statement(self) -> Stmt:
             return self.for_statement()
         if self.match(TokenType.LEFT_BRACE):
             return stmt_ast.Block(self.block())
+        if self.match(TokenType.BREAK):
+            return self.break_statement()
 
         return self.expression_statement()
 
+    # break -> 'break' ;
+    def break_statement(self) -> Stmt:
+        if self.loop_depth == 0:
+            self.error(
+                self.previous(), "Must be inside a loop to use 'break'."
+            )
+
+        self.consume(TokenType.SEMICOLON, "Expect ';' after 'break'.")
+        return stmt_ast.Break()
+
     # whileStmt      → "while" "(" expression ")" statement ;
     def while_statement(self) -> Stmt:
         self.consume(TokenType.LEFT_PAREN, "Expect '(' after 'while'.")
         condition = self.expression()
         self.consume(TokenType.RIGHT_PAREN, "Expect ')' after condition.")
-        body = self.statement()
-
-        return stmt_ast.While(condition, body)
+        try:
+            self.loop_depth += 1
+            body = self.statement()
+            return stmt_ast.While(condition, body)
+        finally:
+            self.loop_depth -= 1
 
     # forStmt        → "for" "(" ( varDecl | exprStmt | ";" )
     #                  expression? ";"
@@ -196,21 +215,25 @@ def for_statement(self) -> Stmt:
             increment = self.expression()
         self.consume(TokenType.RIGHT_PAREN, "Expect ')' after for clauses.")
 
-        body = self.statement()
+        try:
+            self.loop_depth += 1
+            body = self.statement()
 
-        if increment is not None:
-            body = stmt_ast.Block([body, stmt_ast.Expression(increment)])
+            if increment is not None:
+                body = stmt_ast.Block([body, stmt_ast.Expression(increment)])
 
-        if condition is None:
-            condition = expr_ast.Literal(True)
+            if condition is None:
+                condition = expr_ast.Literal(True)
 
-        result: stmt_ast.While | stmt_ast.Block = stmt_ast.While(
-            condition, body
-        )
-        if initializer is not None:
-            result = stmt_ast.Block([initializer, result])
+            result: stmt_ast.While | stmt_ast.Block = stmt_ast.While(
+                condition, body
+            )
+            if initializer is not None:
+                result = stmt_ast.Block([initializer, result])
 
-        return result
+            return result
+        finally:
+            self.loop_depth -= 1
 
     # ifStmt         → "if" "(" expression ")" statement
     #                ( "else" statement )? ;

pylox/scanner.py

@@ -42,6 +42,7 @@ def is_alnum(char: str) -> bool:
     "true": TokenType.TRUE,
     "var": TokenType.VAR,
     "while": TokenType.WHILE,
+    "break": TokenType.BREAK,
 }
 
 

pylox/stmt.py

@@ -32,6 +32,10 @@ def visit_var_stmt(self, stmt) -> typing.Any:
     def visit_while_stmt(self, stmt) -> typing.Any:
         pass
 
+    @abstractmethod
+    def visit_break_stmt(self, stmt) -> typing.Any:
+        pass
+
 
 class Stmt:
     def __init__(self):
@@ -103,3 +107,11 @@ def __init__(self, condition: Expr, body: Stmt):
 
     def accept(self, visitor: StmtVisitor) -> typing.Any:
         return visitor.visit_while_stmt(self)
+
+
+class Break(Stmt):
+    def __init__(self):
+        super().__init__()
+
+    def accept(self, visitor: StmtVisitor) -> typing.Any:
+        return visitor.visit_break_stmt(self)

pylox/tokens.py

@@ -50,6 +50,7 @@ class TokenType(Enum):
     TRUE = auto()
     VAR = auto()
     WHILE = auto()
+    BREAK = auto()
 
     EOF = auto()
 

tests/data/bool/equality.lox

@@ -21,3 +21,5 @@ print false != 0;       // expect: true
 print true != "true";   // expect: true
 print false != "false"; // expect: true
 print false != "";      // expect: true
+
+print 42.0 == 42; // expect: true

tests/data/custom/loop.lox

@@ -3,17 +3,24 @@ var i = 0;
 
 while (i < 10) {
     i = i + 1;
-}
 
-print i; // expect: 10
+    if (i == 7) {
+        break;
+    }
+}
 
+print i; // expect: 7
 
 var a = 0;
 var temp;
 
 for (var b = 1; a < 10000; b = temp + b) {
   temp = a;
   a = b;
+
+  while (true) {
+    break;
+  }
 }
 
 print a; // expect: 10946

tests/test_parser.py

@@ -83,3 +83,16 @@ def handler(err: LoxParseError):
     # THEN
     assert "Expect ')' after expression." in err.value.message
     assert cnt == 2  # both errors have been handled
+
+
+def test_if_parser_handles_break_outside_of_the_loop():
+    # GIVEN
+    src = "break;"
+
+    def handler(err: LoxParseError):
+        # THEN
+        assert "Must be inside a loop to use 'break'." in err.message
+
+    # WHEN
+    tokens = Scanner(src).scan_tokens()
+    Parser(tokens, handler).parse()

tools/generate_ast.py

@@ -93,7 +93,8 @@ def define_visitor(file, base_name, types):
         "If": ('condition : Expr', 'then_branch : Stmt', 'else_branch : typing.Optional[Stmt]'),
         "Print": 'expr : Expr',
         "Var": ('name : Token', "initializer : typing.Optional[Expr]"),
-        "While": ('condition : Expr', 'body : Stmt')
+        "While": ('condition : Expr', 'body : Stmt'),
+        "Break": ()
     }
 
     define_ast("Expr", expressions)