machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_float_literal_expressions.py

@@ -0,0 +1,163 @@
+"""Tests for parsing float literal expressions."""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement
+from machine_dialect.parser import Parser
+from machine_dialect.parser.tests.helper_functions import (
+    assert_literal_expression,
+    assert_program_statements,
+)
+
+
+class TestFloatLiteralExpressions:
+    """Test cases for parsing float literal expressions."""
+
+    @pytest.mark.parametrize(
+        "source,expected_value",
+        [
+            # Simple floats
+            ("0.0", 0.0),
+            ("1.0", 1.0),
+            ("3.14", 3.14),
+            ("2.71", 2.71),
+            # Floats without leading zero
+            (".5", 0.5),
+            (".25", 0.25),
+            (".125", 0.125),
+            # Floats with many decimal places
+            ("3.14159", 3.14159),
+            ("2.71828", 2.71828),
+            ("0.123456789", 0.123456789),
+            # Large floats
+            ("123.456", 123.456),
+            ("9999.9999", 9999.9999),
+            ("1000000.0", 1000000.0),
+            # Small floats
+            ("0.001", 0.001),
+            ("0.0001", 0.0001),
+            ("0.00001", 0.00001),
+            # Edge cases
+            ("999999999.999999999", 999999999.999999999),
+            # Floats with underscores (one on each side)
+            ("_3.14_", 3.14),
+            ("_0.5_", 0.5),
+            ("_1.0_", 1.0),
+            ("_123.456_", 123.456),
+            ("_.25_", 0.25),
+            ("_0.001_", 0.001),
+            ("_0.0_", 0.0),
+        ],
+    )
+    def test_float_literal_expression(self, source: str, expected_value: float) -> None:
+        """Test parsing various float literal expressions.
+
+        Args:
+            source: The source code to parse.
+            expected_value: The expected float value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, expected_value)
+
+    def test_float_with_period(self) -> None:
+        """Test parsing float literal followed by period."""
+        source = "3.14."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, 3.14)
+
+    def test_multiple_float_statements(self) -> None:
+        """Test parsing multiple float literal statements."""
+        source = "1.1. 2.2. 3.3."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 3
+
+        # Check each statement
+        for i, expected_value in enumerate([1.1, 2.2, 3.3]):
+            statement = program.statements[i]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+            assert_literal_expression(statement.expression, expected_value)
+
+    @pytest.mark.parametrize(
+        "source,error_substring",
+        [
+            # Underscore only on left side
+            ("_3.14", "_3.14"),
+            ("_0.5", "_0.5"),
+            ("_123.456", "_123.456"),
+            ("_.25", "_.25"),
+            # Underscore only on right side
+            ("3.14_", "3.14_"),
+            ("0.5_", "0.5_"),
+            ("123.456_", "123.456_"),
+            (".25_", ".25_"),
+            # Multiple underscores
+            ("__3.14__", "__3.14__"),
+            ("___0.5___", "___0.5___"),
+            ("__123.456__", "__123.456__"),
+            # Mixed multiple and single
+            ("__3.14_", "__3.14_"),
+            ("_3.14__", "_3.14__"),
+        ],
+    )
+    def test_invalid_underscore_formats_produce_errors(self, source: str, error_substring: str) -> None:
+        """Test that invalid underscore formats produce lexer errors.
+
+        Args:
+            source: The source code with invalid underscore format.
+            error_substring: Expected substring in the error message.
+        """
+        # Lexer instantiation moved to Parser.parse()
+        parser = Parser()
+
+        # Parse the program (parser collects lexer errors)
+        _ = parser.parse(source)
+
+        # Should have at least one error
+        assert len(parser.errors) >= 1, f"Expected error for invalid format: {source}"
+
+        # Check that the error mentions the invalid token
+        error_messages = [str(error) for error in parser.errors]
+        assert any(error_substring in msg for msg in error_messages), (
+            f"Expected error to mention '{error_substring}', got errors: {error_messages}"
+        )
+
+    def test_mixed_integer_and_float_statements(self) -> None:
+        """Test parsing mixed integer and float literal statements."""
+        source = "42. 3.14. 100. 0.5."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 4
+
+        # Check each statement with expected values and types
+        expected_values = [42, 3.14, 100, 0.5]
+        for i, expected_value in enumerate(expected_values):
+            statement = program.statements[i]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+            assert_literal_expression(statement.expression, expected_value)

machine_dialect/parser/tests/test_identifier_expressions.py

@@ -0,0 +1,57 @@
+"""Tests for parsing identifier expressions."""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement
+from machine_dialect.parser import Parser
+from machine_dialect.parser.tests.helper_functions import (
+    assert_literal_expression,
+    assert_program_statements,
+)
+
+
+class TestIdentifierExpressions:
+    """Test cases for parsing identifier expressions."""
+
+    @pytest.mark.parametrize(
+        "source,expected_value",
+        [
+            # Simple identifiers
+            ("foobar", "foobar"),
+            ("x", "x"),
+            ("myVariableName", "myVariableName"),
+            ("test_variable_name", "test_variable_name"),
+            # Backtick identifiers
+            ("`myVariable`", "myVariable"),
+            ("`x`", "x"),
+            # Multi-word identifiers
+            ("`email address`", "email address"),
+            ("`user name`", "user name"),
+            ("`first name`", "first name"),
+            ("`shopping cart total`", "shopping cart total"),
+            ("`is logged in`", "is logged in"),
+            ("`has been processed`", "has been processed"),
+            # Complex multi-word identifiers
+            ("`customer email address`", "customer email address"),
+            ("`total order amount`", "total order amount"),
+            ("`user account status`", "user account status"),
+        ],
+    )
+    def test_identifier_expression(self, source: str, expected_value: str) -> None:
+        """Test parsing various identifier expressions.
+
+        Args:
+            source: The source code to parse.
+            expected_value: The expected identifier value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source, check_semantics=False)
+
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, expected_value)

machine_dialect/parser/tests/test_if_empty_block.py

@@ -0,0 +1,61 @@
+"""Tests for if statements with empty blocks."""
+
+from machine_dialect.parser import Parser
+
+
+class TestIfEmptyBlock:
+    """Test that if statements with empty blocks generate appropriate errors."""
+
+    def test_if_with_empty_consequence_block(self) -> None:
+        """Test that an if statement with an empty consequence block generates an error."""
+        source = """if True then:
+>
+"""
+        parser = Parser()
+        _ = parser.parse(source)
+
+        # Should have an error about empty consequence block
+        assert len(parser.errors) > 0
+        assert any("must have a non-empty consequence block" in str(error) for error in parser.errors)
+
+    def test_if_with_empty_else_block(self) -> None:
+        """Test that an else block that is empty generates an error."""
+        source = """if True then:
+> Set x to 1.
+else:
+>
+"""
+        parser = Parser()
+        _ = parser.parse(source)
+
+        # Should have an error about empty else block
+        assert len(parser.errors) > 0
+        assert any("must not be empty" in str(error) for error in parser.errors)
+
+    def test_nested_if_with_empty_block(self) -> None:
+        """Test that nested if statements also require non-empty blocks."""
+        source = """if True then:
+> if False then:
+> >
+> Set x to 1."""
+
+        parser = Parser()
+        _ = parser.parse(source)
+
+        # Should have an error about the nested if's empty block
+        assert len(parser.errors) > 0
+        assert any("must have a non-empty consequence block" in str(error) for error in parser.errors)
+
+    def test_if_with_only_empty_lines_in_block(self) -> None:
+        """Test that a block with only empty lines is still considered empty."""
+        source = """if True then:
+>
+>
+>
+"""
+        parser = Parser()
+        _ = parser.parse(source)
+
+        # Should have an error about empty consequence block
+        assert len(parser.errors) > 0
+        assert any("must have a non-empty consequence block" in str(error) for error in parser.errors)

machine_dialect/parser/tests/test_if_statements.py

@@ -0,0 +1,299 @@
+"""Tests for if statements with block statements in the parser.
+
+This module tests the parsing of if statements which support blocks of statements
+marked by '>' symbols for depth tracking.
+"""
+
+import pytest
+
+from machine_dialect.ast import (
+    BlockStatement,
+    Identifier,
+    IfStatement,
+    InfixExpression,
+    SetStatement,
+    WholeNumberLiteral,
+    YesNoLiteral,
+)
+from machine_dialect.parser import Parser
+
+
+class TestIfStatements:
+    """Test parsing of if statements with block statements."""
+
+    def test_parse_basic_if_statement(self) -> None:
+        """Test parsing of basic if statement with single statement in block."""
+        source = """
+        if Yes then:
+        > Set x to 1.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.condition, YesNoLiteral)
+        assert if_stmt.condition.value is True
+
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert if_stmt.consequence.depth == 1
+        assert len(if_stmt.consequence.statements) == 1
+
+        set_stmt = if_stmt.consequence.statements[0]
+        assert isinstance(set_stmt, SetStatement)
+        assert isinstance(set_stmt.name, Identifier)
+        assert set_stmt.name.value == "x"
+        assert isinstance(set_stmt.value, WholeNumberLiteral)
+        assert set_stmt.value.value == 1
+
+        assert if_stmt.alternative is None
+
+    def test_parse_if_else_statement(self) -> None:
+        """Test parsing of if-else statement with blocks."""
+        source = """
+        if Yes then:
+        > Set x to 1.
+        > Set y to 2.
+        else:
+        > Set x to 3.
+        > Set y to 4.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.condition, YesNoLiteral)
+        assert if_stmt.condition.value is True
+
+        # Check consequence block
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert if_stmt.consequence.depth == 1
+        assert len(if_stmt.consequence.statements) == 2
+
+        # Check alternative block
+        assert if_stmt.alternative is not None
+        assert isinstance(if_stmt.alternative, BlockStatement)
+        assert if_stmt.alternative.depth == 1
+        assert len(if_stmt.alternative.statements) == 2
+
+    def test_parse_nested_if_statements(self) -> None:
+        """Test parsing of nested if statements with proper depth."""
+        source = """
+        if Yes then:
+        >
+        > Set foo to 1.
+        >
+        > if No then:
+        > >
+        > > Set bar to 2.
+        > > Set baz to 3.
+        >
+        > Set bax to 4.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        outer_if = program.statements[0]
+        assert isinstance(outer_if, IfStatement)
+
+        assert isinstance(outer_if.consequence, BlockStatement)
+        assert outer_if.consequence.depth == 1
+        assert len(outer_if.consequence.statements) == 3
+
+        # First statement in outer block
+        assert isinstance(outer_if.consequence.statements[0], SetStatement)
+
+        # Nested if statement
+        inner_if = outer_if.consequence.statements[1]
+        assert isinstance(inner_if, IfStatement)
+        assert isinstance(inner_if.consequence, BlockStatement)
+        assert inner_if.consequence.depth == 2
+        assert len(inner_if.consequence.statements) == 2
+
+        # Last statement in outer block
+        assert isinstance(outer_if.consequence.statements[2], SetStatement)
+
+    @pytest.mark.parametrize(
+        "keyword,else_keyword",
+        [
+            ("if", "else"),
+            ("if", "otherwise"),
+            ("when", "else"),
+            ("when", "otherwise"),
+            ("whenever", "else"),
+            ("whenever", "otherwise"),
+        ],
+    )
+    def test_parse_if_keywords_variations(self, keyword: str, else_keyword: str) -> None:
+        """Test parsing of if statements with different keyword variations."""
+        source = f"""
+        {keyword} Yes then:
+        > Set x to 1.
+        {else_keyword}:
+        > Set x to 2.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.condition, YesNoLiteral)
+        assert if_stmt.condition.value is True
+
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert len(if_stmt.consequence.statements) == 1
+
+        assert if_stmt.alternative is not None
+        assert isinstance(if_stmt.alternative, BlockStatement)
+        assert len(if_stmt.alternative.statements) == 1
+
+    def test_parse_if_with_complex_condition(self) -> None:
+        """Test parsing of if statement with complex boolean expression."""
+        source = """
+        if x > 5 and y < 10 then:
+        > Set result to True.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.condition, InfixExpression)
+        assert if_stmt.condition.operator == "and"
+
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert len(if_stmt.consequence.statements) == 1
+
+    def test_parse_empty_blocks(self) -> None:
+        """Test parsing of if statement with empty blocks."""
+        source = """
+        if Yes then:
+        >
+        else:
+        >
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert len(if_stmt.consequence.statements) == 0
+
+        assert if_stmt.alternative is not None
+        assert isinstance(if_stmt.alternative, BlockStatement)
+        assert len(if_stmt.alternative.statements) == 0
+
+    def test_parse_if_without_then_keyword(self) -> None:
+        """Test parsing of if statement with colon directly after condition."""
+        source = """
+        if Yes:
+        > Set x to 1.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert isinstance(program.statements[0], IfStatement)
+
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt.condition, YesNoLiteral)
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert len(if_stmt.consequence.statements) == 1
+
+    def test_block_depth_tracking(self) -> None:
+        """Test that block depth is properly tracked and validated."""
+        source = """
+        if Yes then:
+        > Set x to 1.
+        > > Set y to 2.
+        """
+        parser = Parser()
+        parser.parse(source)
+
+        # This should produce an error - depth suddenly increases
+        assert len(parser.errors) > 0
+        assert any("depth" in str(error).lower() for error in parser.errors)
+
+    def test_missing_period_error(self) -> None:
+        """Test that missing periods generate appropriate errors."""
+        source = """
+        if Yes then:
+        > Set x to 1
+
+        x
+        """
+        parser = Parser()
+        parser.parse(source)
+
+        # Should have errors about missing period
+        assert len(parser.errors) > 0
+        assert any("period" in str(error).lower() or "TokenType.PUNCT_PERIOD" in str(error) for error in parser.errors)
+
+    def test_multiple_if_statements(self) -> None:
+        """Test parsing multiple if statements in sequence."""
+        source = """
+        if Yes then:
+        > Set x to 1.
+
+        if No then:
+        > Set y to 2.
+        else:
+        > Set y to 3.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 2
+        assert all(isinstance(stmt, IfStatement) for stmt in program.statements)
+
+        # First if statement
+        if_stmt1 = program.statements[0]
+        assert isinstance(if_stmt1, IfStatement)
+        assert isinstance(if_stmt1.condition, YesNoLiteral)
+        assert if_stmt1.condition.value is True
+        assert if_stmt1.alternative is None
+
+        # Second if statement
+        if_stmt2 = program.statements[1]
+        assert isinstance(if_stmt2, IfStatement)
+        assert isinstance(if_stmt2.condition, YesNoLiteral)
+        assert if_stmt2.condition.value is False
+        assert if_stmt2.alternative is not None
+
+    def test_if_statements_with_empty_lines(self) -> None:
+        """Test parsing multiple if statements in sequence."""
+        source = """
+        if No then:
+        >
+        > Set y to 2.
+        >
+        else:
+        >
+        > Set y to 3.
+        >
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        assert all(isinstance(stmt, IfStatement) for stmt in program.statements)
+
+        # If statement
+        if_stmt = program.statements[0]
+        assert isinstance(if_stmt, IfStatement)
+        assert isinstance(if_stmt.condition, YesNoLiteral)
+        assert if_stmt.condition.value is False
+        assert if_stmt.alternative is not None

machine_dialect/parser/tests/test_illegal_tokens.py

@@ -0,0 +1,86 @@
+"""Tests for parser handling of illegal tokens.
+
+This module tests that the parser correctly reports MDSyntaxError
+(not MDNameError) when encountering MISC_ILLEGAL tokens from the lexer.
+"""
+
+from machine_dialect.errors.exceptions import MDSyntaxError
+from machine_dialect.parser import Parser
+
+
+class TestIllegalTokenHandling:
+    """Test that illegal tokens are reported as syntax errors."""
+
+    def test_malformed_underscore_literal_syntax_error(self) -> None:
+        """Test that malformed underscore literals produce syntax errors."""
+        source = 'Define `x` as Whole Number. Set `x` to _"unclosed.'
+        parser = Parser()
+
+        parser.parse(source)
+
+        # Should have one syntax error for the illegal token
+        assert len(parser.errors) == 1
+        assert isinstance(parser.errors[0], MDSyntaxError)
+        assert "Illegal token" in str(parser.errors[0])
+        assert '_"unclosed.' in str(parser.errors[0])
+
+    def test_multiple_underscores_with_number(self) -> None:
+        """Test that invalid underscore patterns produce syntax errors."""
+        source = "Define `x` as Whole Number. Set `x` to __42."
+        parser = Parser()
+
+        parser.parse(source)
+
+        # Should have one syntax error for the illegal token
+        assert len(parser.errors) == 1
+        assert isinstance(parser.errors[0], MDSyntaxError)
+        assert "Illegal token" in str(parser.errors[0])
+        assert "__42" in str(parser.errors[0])
+
+    def test_trailing_underscore_after_number(self) -> None:
+        """Test that numbers with trailing underscores produce syntax errors."""
+        source = "Define `x` as Whole Number. Set `x` to 42_."
+        parser = Parser()
+
+        parser.parse(source)
+
+        # Should have one syntax error for the illegal token
+        assert len(parser.errors) == 1
+        assert isinstance(parser.errors[0], MDSyntaxError)
+        assert "Illegal token" in str(parser.errors[0])
+        assert "42_" in str(parser.errors[0])
+
+    def test_incomplete_underscore_wrapped_number(self) -> None:
+        """Test that incomplete underscore-wrapped numbers produce syntax errors."""
+        source = "Define `x` as Whole Number. Set `x` to _42."
+        parser = Parser()
+
+        parser.parse(source)
+
+        # Should have one syntax error for the illegal token
+        assert len(parser.errors) == 1
+        assert isinstance(parser.errors[0], MDSyntaxError)
+        assert "Illegal token" in str(parser.errors[0])
+        assert "_42" in str(parser.errors[0])
+
+    def test_recovery_after_illegal_token(self) -> None:
+        """Test that parser recovers and continues after illegal tokens."""
+        source = "Define `x` as Whole Number. Define `y` as Whole Number. Set `x` to _42. Set `y` to _10_."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        # Should have one syntax error for the first illegal token
+        assert len(parser.errors) == 1
+        assert isinstance(parser.errors[0], MDSyntaxError)
+        assert "_42" in str(parser.errors[0])
+
+        # Should have parsed four statements (2 Define + 2 Set)
+        assert len(program.statements) == 4
+        # First two are Define statements
+        assert program.statements[0] is not None
+        assert program.statements[1] is not None
+        # Third statement (Set with _42) has an error
+        assert program.statements[2] is not None
+        # Fourth statement should be complete (10 is properly wrapped)
+        assert program.statements[3] is not None