machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_prefix_expressions.py

@@ -0,0 +1,415 @@
+"""Tests for parsing prefix expressions.
+
+This module tests the parser's ability to handle prefix expressions including:
+- Negative numbers (-42, -3.14)
+- Boolean negation (not True, not False)
+"""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement, Identifier, PrefixExpression
+from machine_dialect.parser import Parser
+from machine_dialect.parser.tests.helper_functions import (
+    assert_literal_expression,
+    assert_program_statements,
+)
+
+
+class TestPrefixExpressions:
+    """Test parsing of prefix expressions."""
+
+    @pytest.mark.parametrize(
+        "source,operator,value",
+        [
+            # Negative integers
+            ("-5", "-", 5),
+            ("-42", "-", 42),
+            ("-123", "-", 123),
+            ("-0", "-", 0),
+            ("-999", "-", 999),
+            # Negative integers with underscores wrapping the positive number
+            ("-_5_", "-", 5),
+            ("-_42_", "-", 42),
+            ("-_123_", "-", 123),
+            # Underscore-wrapped negative integers (entire expression)
+            # ("_-5_", "-", 5),
+            # ("_-42_", "-", 42),
+            # ("_-123_", "-", 123),
+        ],
+    )
+    def test_negative_integer_expressions(self, source: str, operator: str, value: int) -> None:
+        """Test parsing negative integer expressions.
+
+        Args:
+            source: The source code containing a negative integer.
+            operator: The expected operator (should be "-").
+            value: The expected positive integer value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        # Check that it's a prefix expression
+        assert isinstance(statement.expression, PrefixExpression)
+        prefix_exp = statement.expression
+
+        # Check the operator
+        assert prefix_exp.operator == operator
+
+        # Check the right expression (should be the positive number)
+        assert prefix_exp.right is not None
+        assert_literal_expression(prefix_exp.right, value)
+
+    @pytest.mark.parametrize(
+        "source,operator,value",
+        [
+            # Negative floats
+            ("-3.14", "-", 3.14),
+            ("-0.5", "-", 0.5),
+            ("-123.456", "-", 123.456),
+            ("-0.0", "-", 0.0),
+            ("-.5", "-", 0.5),
+            ("-.25", "-", 0.25),
+            # Negative floats with underscores wrapping the positive number
+            ("-_3.14_", "-", 3.14),
+            ("-_0.5_", "-", 0.5),
+            ("-_.25_", "-", 0.25),
+            # Underscore-wrapped negative floats (entire expression)
+            # ("_-3.14_", "-", 3.14),
+            # ("_-0.5_", "-", 0.5),
+            # ("_-.25_", "-", 0.25),
+        ],
+    )
+    def test_negative_float_expressions(self, source: str, operator: str, value: float) -> None:
+        """Test parsing negative float expressions.
+
+        Args:
+            source: The source code containing a negative float.
+            operator: The expected operator (should be "-").
+            value: The expected positive float value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        # Check that it's a prefix expression
+        assert isinstance(statement.expression, PrefixExpression)
+        prefix_exp = statement.expression
+
+        # Check the operator
+        assert prefix_exp.operator == operator
+
+        # Check the right expression (should be the positive number)
+        assert prefix_exp.right is not None
+        assert_literal_expression(prefix_exp.right, value)
+
+    @pytest.mark.parametrize(
+        "source,operator,value",
+        [
+            # Boolean negation
+            ("not Yes", "not", True),
+            ("not No", "not", False),
+            # Boolean negation with underscores
+            ("not _Yes_", "not", True),
+            ("not _No_", "not", False),
+            # Underscore-wrapped entire negation expression
+            # ("_not True_", "not", True),
+            # ("_not False_", "not", False),
+            # Case insensitive NOT
+            ("NOT Yes", "not", True),
+            ("NOT No", "not", False),
+            ("Not Yes", "not", True),
+            ("Not No", "not", False),
+            ("nOt Yes", "not", True),
+            ("nOt No", "not", False),
+            # Case insensitive boolean values with negation
+            ("not yes", "not", True),
+            ("not no", "not", False),
+            ("NOT YES", "not", True),
+            ("NOT NO", "not", False),
+        ],
+    )
+    def test_boolean_negation_expressions(self, source: str, operator: str, value: bool) -> None:
+        """Test parsing boolean negation expressions.
+
+        Args:
+            source: The source code containing a negated boolean.
+            operator: The expected operator (should be "not").
+            value: The expected boolean value being negated.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        # Check that it's a prefix expression
+        assert isinstance(statement.expression, PrefixExpression)
+        prefix_exp = statement.expression
+
+        # Check the operator (should be lowercase "not")
+        assert prefix_exp.operator == operator
+
+        # Check the right expression (should be the boolean value)
+        assert prefix_exp.right is not None
+        assert_literal_expression(prefix_exp.right, value)
+
+    def test_multiple_prefix_expressions(self) -> None:
+        """Test parsing multiple prefix expressions in sequence."""
+        source = "-42. not Yes. -3.14. not No."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 4
+
+        # First statement: -42
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "-"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, 42)
+
+        # Second statement: not True
+        statement = program.statements[1]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "not"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, True)
+
+        # Third statement: -3.14
+        statement = program.statements[2]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "-"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, 3.14)
+
+        # Fourth statement: not False
+        statement = program.statements[3]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "not"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, False)
+
+    def test_prefix_expression_with_identifier(self) -> None:
+        """Test prefix expressions with identifiers."""
+        source = "-x. not `is valid`."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 2
+
+        # First statement: -x
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "-"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, "x")
+
+        # Second statement: not `is valid`
+        statement = program.statements[1]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "not"
+        assert statement.expression.right is not None
+        assert_literal_expression(statement.expression.right, "is valid")
+
+    def test_double_negation(self) -> None:
+        """Test parsing double negation expressions."""
+        source = "--42. not not Yes."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 2
+
+        # First statement: --42 (negative of negative 42)
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "-"
+
+        # The right side should be another prefix expression
+        assert statement.expression.right is not None
+        assert isinstance(statement.expression.right, PrefixExpression)
+        assert statement.expression.right.operator == "-"
+        assert statement.expression.right.right is not None
+        assert_literal_expression(statement.expression.right.right, 42)
+
+        # Second statement: not not True
+        statement = program.statements[1]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert isinstance(statement.expression, PrefixExpression)
+        assert statement.expression.operator == "not"
+
+        # The right side should be another prefix expression
+        assert statement.expression.right is not None
+        assert isinstance(statement.expression.right, PrefixExpression)
+        assert statement.expression.right.operator == "not"
+        assert statement.expression.right.right is not None
+        assert_literal_expression(statement.expression.right.right, True)
+
+    def test_boolean_negation_with_identifiers(self) -> None:
+        """Test parsing boolean negation with identifier expressions."""
+        test_cases = [
+            ("not x", "not", "x"),
+            ("not isValid", "not", "isValid"),
+            ("not `is valid`", "not", "is valid"),
+            ("not foo", "not", "foo"),
+            ("NOT bar", "not", "bar"),
+        ]
+
+        for source, expected_operator, expected_identifier in test_cases:
+            parser = Parser()
+
+            program = parser.parse(source)
+
+            assert len(parser.errors) == 0, f"Parser errors for '{source}': {parser.errors}"
+            assert_program_statements(parser, program)
+
+            statement = program.statements[0]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+
+            # Check it's a prefix expression
+            prefix_exp = statement.expression
+            assert isinstance(prefix_exp, PrefixExpression)
+            assert prefix_exp.operator == expected_operator
+
+            # Check the right side is an identifier
+            assert prefix_exp.right is not None
+            assert isinstance(prefix_exp.right, Identifier)
+            assert prefix_exp.right.value == expected_identifier
+
+    def test_boolean_negation_with_non_boolean_literals(self) -> None:
+        """Test that using 'not' with non-boolean literals parses successfully.
+
+        Note: Since this language follows Java's approach where 'not' only accepts
+        boolean values, type checking would happen at a later semantic analysis stage,
+        not during parsing. The parser accepts these syntactically valid constructs.
+        """
+        test_cases = [
+            ("not 42", "not", 42),
+            ("not 0", "not", 0),
+            ("not 3.14", "not", 3.14),
+            ("not 0.0", "not", 0.0),
+            # ("not -5", "not", -5),  # This creates nested prefix expressions: not (- 5)
+            ("NOT 123", "not", 123),
+            # String literals - uncomment when string parsing is implemented
+            # ("not \"hello\"", "not", "hello"),
+            # ("not 'world'", "not", "world"),
+            # ("not \"\"", "not", ""),
+        ]
+
+        for source, expected_operator, expected_value in test_cases:
+            parser = Parser()
+
+            program = parser.parse(source)
+
+            # These should parse successfully - type errors would be caught in semantic analysis
+            assert len(parser.errors) == 0, f"Parser errors for '{source}': {parser.errors}"
+            assert_program_statements(parser, program)
+
+            statement = program.statements[0]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+
+            # Check it's a prefix expression
+            prefix_exp = statement.expression
+            assert isinstance(prefix_exp, PrefixExpression)
+            assert prefix_exp.operator == expected_operator
+
+            # The right side should be parsed as the appropriate literal
+            assert prefix_exp.right is not None
+            assert_literal_expression(prefix_exp.right, expected_value)
+
+    def test_boolean_negation_with_nested_prefix(self) -> None:
+        """Test that 'not -5' creates nested prefix expressions."""
+        source = "not -5"
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        # Check outer prefix expression (not)
+        outer_prefix = statement.expression
+        assert isinstance(outer_prefix, PrefixExpression)
+        assert outer_prefix.operator == "not"
+
+        # Check inner prefix expression (-)
+        assert outer_prefix.right is not None
+        inner_prefix = outer_prefix.right
+        assert isinstance(inner_prefix, PrefixExpression)
+        assert inner_prefix.operator == "-"
+
+        # Check the innermost literal (5)
+        assert inner_prefix.right is not None
+        assert_literal_expression(inner_prefix.right, 5)
+
+    def test_prefix_expression_string_representation(self) -> None:
+        """Test the string representation of prefix expressions."""
+        # Test cases with expected string representations
+        test_cases = [
+            ("-42", "(-_42_)"),
+            ("not Yes", "(not _Yes_)"),
+            ("-3.14", "(-_3.14_)"),
+            ("not No", "(not _No_)"),
+            ("--5", "(-(-_5_))"),
+            ("not not Yes", "(not (not _Yes_))"),
+        ]
+
+        for source, expected in test_cases:
+            parser = Parser()
+            program = parser.parse(source)
+
+            assert len(parser.errors) == 0
+            assert len(program.statements) == 1
+
+            statement = program.statements[0]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+
+            # Check string representation
+            assert str(statement.expression) == expected

machine_dialect/parser/tests/test_program.py

@@ -0,0 +1,13 @@
+from machine_dialect.ast import Program
+from machine_dialect.parser import Parser
+
+
+class TestParser:
+    def test_parse_program(self) -> None:
+        source: str = "Set `X` to 5."
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert isinstance(program, Program)

machine_dialect/parser/tests/test_return_statements.py

@@ -0,0 +1,89 @@
+"""Tests for return statement parsing."""
+
+from machine_dialect.ast import ReturnStatement
+from machine_dialect.parser import Parser
+
+
+class TestReturnStatements:
+    """Test parsing of return statements."""
+
+    def test_give_back_statement(self) -> None:
+        """Test parsing 'give back' return statement."""
+        source = "give back 42"
+        parser = Parser()
+
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser had errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, ReturnStatement)
+        assert statement.token.literal == "give back"
+
+    def test_gives_back_statement(self) -> None:
+        """Test parsing 'gives back' return statement."""
+        source = "gives back true"
+        parser = Parser()
+
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser had errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, ReturnStatement)
+        assert statement.token.literal == "gives back"
+
+    def test_multiple_return_statements(self) -> None:
+        """Test parsing multiple return statements."""
+        source = """
+            give back 1.
+            gives back 2.
+        """
+        parser = Parser()
+
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser had errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        # First statement
+        statement1 = program.statements[0]
+        assert isinstance(statement1, ReturnStatement)
+        assert statement1.token.literal == "give back"
+
+        # Second statement
+        statement2 = program.statements[1]
+        assert isinstance(statement2, ReturnStatement)
+        assert statement2.token.literal == "gives back"
+
+    def test_return_with_set_statement(self) -> None:
+        """Test parsing return statement followed by set statement."""
+        source = """
+            Define `x` as Whole Number.
+            give back 42.
+            Set `x` to 10
+        """
+        parser = Parser()
+
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser had errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # First statement should be define
+        from machine_dialect.ast import DefineStatement, SetStatement
+
+        statement1 = program.statements[0]
+        assert isinstance(statement1, DefineStatement)
+
+        # Second statement should be return
+        statement2 = program.statements[1]
+        assert isinstance(statement2, ReturnStatement)
+        assert statement2.token.literal == "give back"
+
+        # Third statement should be set
+        statement3 = program.statements[2]
+        assert isinstance(statement3, SetStatement)
+        assert statement3.token.literal == "Set"

machine_dialect/parser/tests/test_set_statements.py

@@ -0,0 +1,152 @@
+import pytest
+
+from machine_dialect.ast import Identifier, Program, SetStatement
+from machine_dialect.lexer import TokenType
+from machine_dialect.parser import Parser
+
+
+class TestSetStatements:
+    def test_parse_set_integer(self) -> None:
+        source: str = "Set `X` to 1"
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, SetStatement)
+        assert statement.token.literal == "Set"
+
+        assert statement.name is not None
+        assert isinstance(statement.name, Identifier)
+        assert statement.name.value == "X"
+        assert statement.name.token.literal == "X"
+
+    def test_parse_set_float(self) -> None:
+        source: str = "Set `price` to 3.14"
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, SetStatement)
+        assert statement.token.literal == "Set"
+
+        assert statement.name is not None
+        assert isinstance(statement.name, Identifier)
+        assert statement.name.value == "price"
+        assert statement.name.token.literal == "price"
+
+    def test_parse_set_string(self) -> None:
+        source: str = 'Set `Z` to "Hello, World!"'
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, SetStatement)
+        assert statement.token.literal == "Set"
+
+        assert statement.name is not None
+        assert isinstance(statement.name, Identifier)
+        assert statement.name.value == "Z"
+        assert statement.name.token.literal == "Z"
+
+    def test_parse_multiple_set_statements(self) -> None:
+        source: str = "\n".join(
+            [
+                "Set `X` to 1.",
+                "Set `price` to 3.14.",
+                'Set `Z` to "Hello, World!".',
+            ]
+        )
+
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 3
+
+        # Check first statement
+        statement1 = program.statements[0]
+        assert isinstance(statement1, SetStatement)
+        assert statement1.name is not None
+        assert statement1.name.value == "X"
+        assert statement1.name.token.type == TokenType.MISC_IDENT
+        assert statement1.name.token.literal == "X"
+
+        # Check second statement
+        statement2 = program.statements[1]
+        assert isinstance(statement2, SetStatement)
+        assert statement2.name is not None
+        assert statement2.name.value == "price"
+        assert statement2.name.token.type == TokenType.MISC_IDENT
+        assert statement2.name.token.literal == "price"
+
+        # Check third statement
+        statement3 = program.statements[2]
+        assert isinstance(statement3, SetStatement)
+        assert statement3.name is not None
+        assert statement3.name.value == "Z"
+        assert statement3.name.token.type == TokenType.MISC_IDENT
+        assert statement3.name.token.literal == "Z"
+
+    def test_set_statement_string_representation(self) -> None:
+        source: str = "Set `X` to 1"
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        statement = program.statements[0]
+        assert isinstance(statement, SetStatement)
+
+        # Test the string representation
+        program_str = str(program)
+        assert program_str is not None  # Should have some string representation
+
+    @pytest.mark.parametrize(
+        "source",
+        [
+            "Set `foo` to 1 if `certain_condition`, else 0",
+            "Set `foo` to 1 if `certain_condition`, otherwise 0",
+            "Set `foo` to 1 when `certain_condition`, else 0",
+            "Set `foo` to 1 when `certain_condition`, otherwise 0",
+            "Set `foo` to 1 whenever `certain_condition`, else 0",
+            "Set `foo` to 1 whenever `certain_condition`, otherwise 0",
+            "Set `foo` to 1 if `certain_condition`; else 0",
+            "Set `foo` to 1 if `certain_condition`; otherwise 0",
+            "Set `foo` to 1 when `certain_condition`; else 0",
+            "Set `foo` to 1 when `certain_condition`; otherwise 0",
+            "Set `foo` to 1 whenever `certain_condition`; else 0",
+            "Set `foo` to 1 whenever `certain_condition`; otherwise 0",
+        ],
+    )
+    def test_parse_ternary_expressions(self, source: str) -> None:
+        parser: Parser = Parser()
+
+        program: Program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, SetStatement)
+        assert statement.token.literal == "Set"
+
+        assert statement.name is not None
+        assert isinstance(statement.name, Identifier)
+        assert statement.name.value == "foo"
+        assert statement.name.token.literal == "foo"
+
+        # The value should be a ternary/conditional expression
+        assert statement.value is not None