machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_strict_equality.py

@@ -0,0 +1,258 @@
+"""Tests for parsing strict equality expressions.
+
+This module tests the parser's ability to handle strict equality and
+strict inequality expressions, ensuring they are distinguished from
+regular equality operators.
+"""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement, InfixExpression
+from machine_dialect.parser import Parser
+from machine_dialect.parser.tests.helper_functions import (
+    assert_infix_expression,
+    assert_program_statements,
+)
+
+
+class TestStrictEqualityExpressions:
+    """Test parsing of strict equality expressions."""
+
+    @pytest.mark.parametrize(
+        "source,left,operator,right",
+        [
+            # Strict equality with integers
+            ("5 is strictly equal to 5", 5, "is strictly equal to", 5),
+            ("10 is exactly equal to 10", 10, "is strictly equal to", 10),
+            ("42 is identical to 42", 42, "is strictly equal to", 42),
+            # Strict inequality with integers
+            ("5 is not strictly equal to 10", 5, "is not strictly equal to", 10),
+            ("10 is not exactly equal to 20", 10, "is not strictly equal to", 20),
+            ("7 is not identical to 8", 7, "is not strictly equal to", 8),
+            # Strict equality with floats
+            ("3.14 is strictly equal to 3.14", 3.14, "is strictly equal to", 3.14),
+            ("2.5 is exactly equal to 2.5", 2.5, "is strictly equal to", 2.5),
+            # Strict equality with booleans
+            ("Yes is strictly equal to Yes", True, "is strictly equal to", True),
+            ("No is identical to No", False, "is strictly equal to", False),
+            # Strict equality with identifiers
+            ("x is strictly equal to y", "x", "is strictly equal to", "y"),
+            ("foo is exactly equal to bar", "foo", "is strictly equal to", "bar"),
+            ("`value` is identical to expected", "value", "is strictly equal to", "expected"),
+            # Mixed types (would fail at runtime for strict equality)
+            ("5 is strictly equal to 5.0", 5, "is strictly equal to", 5.0),
+            ("Yes is strictly equal to 1", True, "is strictly equal to", 1),
+        ],
+    )
+    def test_strict_equality_expressions(
+        self, source: str, left: int | float | bool | str, operator: str, right: int | float | bool | str
+    ) -> None:
+        """Test parsing strict equality and inequality expressions.
+
+        Args:
+            source: The source code containing a strict equality expression.
+            left: Expected left operand value.
+            operator: Expected operator string representation.
+            right: Expected right operand value.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        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
+
+        assert_infix_expression(statement.expression, left, operator, right)
+
+    def test_strict_vs_value_equality(self) -> None:
+        """Test that strict and value equality are parsed as different operators."""
+        # Value equality
+        parser1 = Parser()
+        program1 = parser1.parse("x equals y")
+        assert len(parser1.errors) == 0
+
+        statement1 = program1.statements[0]
+        assert isinstance(statement1, ExpressionStatement)
+        expr1 = statement1.expression
+        assert isinstance(expr1, InfixExpression)
+        assert expr1.operator == "equals"
+
+        # Strict equality
+        parser2 = Parser()
+        program2 = parser2.parse("x is strictly equal to y")
+        assert len(parser2.errors) == 0
+
+        statement2 = program2.statements[0]
+        assert isinstance(statement2, ExpressionStatement)
+        expr2 = statement2.expression
+        assert isinstance(expr2, InfixExpression)
+        assert expr2.operator == "is strictly equal to"
+
+        # Ensure they're different
+        assert expr1.operator != expr2.operator
+
+    def test_strict_equality_precedence(self) -> None:
+        """Test that strict equality has the same precedence as regular equality."""
+        test_cases = [
+            # Arithmetic has higher precedence than strict equality
+            ("5 + 3 is strictly equal to 8", "((_5_ + _3_) is strictly equal to _8_)"),
+            ("2 * 3 is exactly equal to 6", "((_2_ * _3_) is strictly equal to _6_)"),
+            # Logical operators have lower precedence
+            (
+                "x is strictly equal to 5 and y is strictly equal to 10",
+                "((`x` is strictly equal to _5_) and (`y` is strictly equal to _10_))",
+            ),
+            (
+                "`a` is identical to `b` or `c` is not identical to `d`",
+                "((`a` is strictly equal to `b`) or (`c` is not strictly equal to `d`))",
+            ),
+            # Mixed with regular equality
+            (
+                "x equals y and z is strictly equal to w",
+                "((`x` equals `y`) and (`z` is strictly equal to `w`))",
+            ),
+            # Strict inequality with precedence
+            (
+                "5 + 3 is not strictly equal to 10",
+                "((_5_ + _3_) is not strictly equal to _10_)",
+            ),
+            (
+                "x * 2 is not exactly equal to y",
+                "((`x` * _2_) is not strictly equal to `y`)",
+            ),
+        ]
+
+        for source, expected_structure in test_cases:
+            parser = Parser()
+            program = parser.parse(source, check_semantics=False)
+
+            assert len(parser.errors) == 0, f"Parser errors for '{source}': {parser.errors}"
+            assert len(program.statements) == 1
+
+            statement = program.statements[0]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+
+            # Check string representation matches expected precedence
+            actual = str(statement.expression)
+            assert actual == expected_structure, f"For '{source}': expected {expected_structure}, got {actual}"
+
+    def test_strict_equality_in_conditionals(self) -> None:
+        """Test strict equality in if statements."""
+        from machine_dialect.ast import BlockStatement, IfStatement
+
+        test_cases = [
+            # Basic if with strict equality
+            (
+                """
+                if x is strictly equal to 5 then:
+                > give back _yes_.
+                """,
+                "x",
+                "is strictly equal to",
+                5,
+            ),
+            # If with strict inequality
+            (
+                """
+                Define `result` as Text or Empty.
+                if `value` is not strictly equal to empty then:
+                > set `result` to `value`.
+                """,
+                "value",
+                "is not strictly equal to",
+                "empty",
+            ),
+            # If-else with strict equality
+            (
+                """
+                if `a` is exactly equal to `b` then:
+                > give back _Same_.
+                else:
+                > give back _Different_.
+                """,
+                "a",
+                "is strictly equal to",
+                "b",
+            ),
+            # Complex condition with strict equality
+            (
+                """
+                Define `flag` as Yes/No.
+                if x is identical to 0 or y is not identical to 0 then:
+                > set `flag` to _yes_.
+                """,
+                None,  # Complex condition, skip simple checks
+                None,
+                None,
+            ),
+        ]
+
+        for test_input in test_cases:
+            source = test_input[0]
+            expected_left = test_input[1]
+            expected_op = test_input[2]
+            expected_right = test_input[3]
+
+            parser = Parser()
+            program = parser.parse(source, check_semantics=False)
+
+            assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+
+            # Skip Define statement if present
+            stmt_idx = 0
+            if "Define" in source:
+                stmt_idx = 1
+                assert len(program.statements) == 2
+            else:
+                assert len(program.statements) == 1
+
+            # Check it's an if statement
+            if_stmt = program.statements[stmt_idx]
+            assert isinstance(if_stmt, IfStatement)
+
+            # Check the condition is parsed correctly
+            if expected_left is not None:  # Simple condition check
+                condition = if_stmt.condition
+                assert isinstance(condition, InfixExpression)
+                assert condition.operator == expected_op
+
+                # Check left operand
+                if isinstance(expected_left, str):
+                    assert str(condition.left) == f"`{expected_left}`"
+                else:
+                    assert str(condition.left) == f"_{expected_left}_"
+
+                # Check right operand
+                if isinstance(expected_right, str):
+                    # Special keywords like empty are parsed differently
+                    if expected_right == "empty":
+                        assert str(condition.right) == "empty"
+                    else:
+                        assert str(condition.right) == f"`{expected_right}`"
+                else:
+                    assert str(condition.right) == f"_{expected_right}_"
+
+            # Check consequence block exists
+            assert isinstance(if_stmt.consequence, BlockStatement)
+            assert len(if_stmt.consequence.statements) > 0
+
+    def test_complex_expressions_with_strict_equality(self) -> None:
+        """Test complex expressions involving strict equality."""
+        test_cases = [
+            "not x is strictly equal to y",
+            "(x + 5) is exactly equal to (y - 3)",
+            "`first` is identical to `second`",
+            "result is not strictly equal to empty",
+        ]
+
+        for source in test_cases:
+            parser = Parser()
+            program = parser.parse(source, check_semantics=False)
+
+            # Should parse without errors
+            assert len(parser.errors) == 0, f"Parser errors for '{source}': {parser.errors}"
+            assert len(program.statements) == 1

machine_dialect/parser/tests/test_symbol_table.py

@@ -0,0 +1,217 @@
+import pytest
+
+from machine_dialect.parser.symbol_table import SymbolTable, VariableInfo
+
+
+class TestVariableInfo:
+    """Test VariableInfo class."""
+
+    def test_single_type(self) -> None:
+        """Test variable with single type."""
+        info = VariableInfo(["Whole Number"])
+        assert info.allows_type("Whole Number")
+        assert not info.allows_type("Text")
+        assert str(info) == "VariableInfo(types=Whole Number, uninitialized)"
+
+    def test_union_types(self) -> None:
+        """Test variable with union types."""
+        info = VariableInfo(["Whole Number", "Text", "Yes/No"])
+        assert info.allows_type("Whole Number")
+        assert info.allows_type("Text")
+        assert info.allows_type("Yes/No")
+        assert not info.allows_type("Float")
+
+    def test_initialized_status(self) -> None:
+        """Test initialized status tracking."""
+        info = VariableInfo(["Text"], initialized=False)
+        assert str(info) == "VariableInfo(types=Text, uninitialized)"
+
+        info.initialized = True
+        assert str(info) == "VariableInfo(types=Text, initialized)"
+
+    def test_definition_location(self) -> None:
+        """Test that definition location is tracked."""
+        info = VariableInfo(["Whole Number"], definition_line=10, definition_pos=5)
+        assert info.definition_line == 10
+        assert info.definition_pos == 5
+
+
+class TestSymbolTable:
+    """Test SymbolTable class."""
+
+    def test_define_and_lookup(self) -> None:
+        """Test defining and looking up variables."""
+        table = SymbolTable()
+
+        # Define a variable
+        table.define("count", ["Whole Number"], line=1, position=5)
+
+        # Look it up
+        info = table.lookup("count")
+        assert info is not None
+        assert info.type_spec == ["Whole Number"]
+        assert not info.initialized
+
+    def test_redefinition_error(self) -> None:
+        """Test that redefinition raises error."""
+        table = SymbolTable()
+
+        # First definition should succeed
+        table.define("x", ["Whole Number"], line=1, position=1)
+
+        # Second definition should raise error
+        with pytest.raises(NameError) as exc_info:
+            table.define("x", ["Text"], line=2, position=1)
+
+        assert "already defined" in str(exc_info.value)
+        assert "line 1" in str(exc_info.value)
+
+    def test_lookup_undefined(self) -> None:
+        """Test looking up undefined variable returns None."""
+        table = SymbolTable()
+        info = table.lookup("undefined")
+        assert info is None
+
+    def test_mark_initialized(self) -> None:
+        """Test marking variable as initialized."""
+        table = SymbolTable()
+        table.define("message", ["Text"])
+
+        # Should be uninitialized at first
+        info = table.lookup("message")
+        assert info is not None
+        assert not info.initialized
+
+        # Mark as initialized
+        table.mark_initialized("message")
+
+        # Should now be initialized
+        info = table.lookup("message")
+        assert info is not None
+        assert info.initialized
+
+    def test_mark_undefined_raises_error(self) -> None:
+        """Test marking undefined variable raises error."""
+        table = SymbolTable()
+
+        with pytest.raises(NameError) as exc_info:
+            table.mark_initialized("undefined")
+
+        assert "not defined" in str(exc_info.value)
+
+    def test_nested_scopes(self) -> None:
+        """Test nested scope handling."""
+        # Global scope
+        global_table = SymbolTable()
+        global_table.define("global_var", ["Whole Number"])
+
+        # Enter function scope
+        func_table = global_table.enter_scope()
+        func_table.define("local_var", ["Text"])
+
+        # Can see both variables from inner scope
+        assert func_table.lookup("global_var") is not None
+        assert func_table.lookup("local_var") is not None
+
+        # Can only see global from outer scope
+        assert global_table.lookup("global_var") is not None
+        assert global_table.lookup("local_var") is None
+
+    def test_exit_scope(self) -> None:
+        """Test exiting scope returns parent."""
+        global_table = SymbolTable()
+        func_table = global_table.enter_scope()
+
+        # Exit should return to parent
+        parent = func_table.exit_scope()
+        assert parent is global_table
+
+        # Exit from global should return None
+        assert global_table.exit_scope() is None
+
+    def test_is_defined_in_current_scope(self) -> None:
+        """Test checking if variable is in current scope only."""
+        global_table = SymbolTable()
+        global_table.define("x", ["Whole Number"])
+
+        local_table = global_table.enter_scope()
+        local_table.define("y", ["Text"])
+
+        # x is not in local scope (it's in parent)
+        assert not local_table.is_defined_in_current_scope("x")
+        # y is in local scope
+        assert local_table.is_defined_in_current_scope("y")
+        # x is in global scope
+        assert global_table.is_defined_in_current_scope("x")
+
+    def test_mark_initialized_in_parent_scope(self) -> None:
+        """Test marking variable in parent scope as initialized."""
+        global_table = SymbolTable()
+        global_table.define("global_var", ["Whole Number"])
+
+        # Enter nested scope
+        local_table = global_table.enter_scope()
+
+        # Mark parent's variable as initialized from child scope
+        local_table.mark_initialized("global_var")
+
+        # Check it's marked in the parent
+        info = global_table.lookup("global_var")
+        assert info is not None
+        assert info.initialized
+
+    def test_multiple_nested_scopes(self) -> None:
+        """Test multiple levels of nesting."""
+        level1 = SymbolTable()
+        level1.define("var1", ["Whole Number"])
+
+        level2 = level1.enter_scope()
+        level2.define("var2", ["Text"])
+
+        level3 = level2.enter_scope()
+        level3.define("var3", ["Yes/No"])
+
+        # Level 3 can see all variables
+        assert level3.lookup("var1") is not None
+        assert level3.lookup("var2") is not None
+        assert level3.lookup("var3") is not None
+
+        # Level 2 can see var1 and var2
+        assert level2.lookup("var1") is not None
+        assert level2.lookup("var2") is not None
+        assert level2.lookup("var3") is None
+
+        # Level 1 can only see var1
+        assert level1.lookup("var1") is not None
+        assert level1.lookup("var2") is None
+        assert level1.lookup("var3") is None
+
+    def test_string_representation(self) -> None:
+        """Test string representation of symbol table."""
+        table = SymbolTable()
+        table.define("x", ["Whole Number"])
+        table.define("y", ["Text", "Number"])
+
+        str_repr = str(table)
+        assert "Symbol Table:" in str_repr
+        assert "x: VariableInfo" in str_repr
+        assert "y: VariableInfo" in str_repr
+
+        # Test with parent
+        child = table.enter_scope()
+        child.define("z", ["Yes/No"])
+        str_repr = str(child)
+        assert "has parent scope" in str_repr
+
+    def test_union_type_checking(self) -> None:
+        """Test type checking with union types."""
+        table = SymbolTable()
+        table.define("value", ["Whole Number", "Text", "Empty"])
+
+        info = table.lookup("value")
+        assert info is not None
+        assert info.allows_type("Whole Number")
+        assert info.allows_type("Text")
+        assert info.allows_type("Empty")
+        assert not info.allows_type("Float")
+        assert not info.allows_type("Yes/No")

machine_dialect/parser/tests/test_url_literal_expressions.py

@@ -0,0 +1,209 @@
+"""Tests for URL literal expressions in the parser."""
+
+import machine_dialect.ast as ast
+from machine_dialect.parser import Parser
+
+
+class TestURLLiteralExpressions:
+    """Test parsing of URL literal expressions."""
+
+    def test_parse_simple_url_literal(self) -> None:
+        """Test parsing a simple URL literal."""
+        source = '_"https://example.com"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "https://example.com"
+
+    def test_parse_complex_url_literal(self) -> None:
+        """Test parsing a complex URL with query parameters."""
+        source = '_"https://api.example.com/v1/users?id=123&active=true#profile"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "https://api.example.com/v1/users?id=123&active=true#profile"
+
+    def test_parse_ftp_url_literal(self) -> None:
+        """Test parsing an FTP URL literal."""
+        source = '_"ftp://files.example.com/data.zip"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "ftp://files.example.com/data.zip"
+
+    def test_parse_mailto_url_literal(self) -> None:
+        """Test parsing a mailto URL literal."""
+        source = '_"mailto:user@example.com"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "mailto:user@example.com"
+
+    def test_url_vs_string_distinction(self) -> None:
+        """Test that URLs and regular strings are parsed as different types."""
+        # Parse URL
+        url_source = '_"https://example.com"_.'
+        parser1 = Parser()
+        url_program = parser1.parse(url_source)
+
+        assert url_program is not None
+        url_stmt = url_program.statements[0]
+        assert isinstance(url_stmt, ast.ExpressionStatement)
+        assert isinstance(url_stmt.expression, ast.URLLiteral)
+
+        # Parse regular string
+        string_source = '_"not a url"_.'
+        parser2 = Parser()
+        string_program = parser2.parse(string_source)
+
+        assert string_program is not None
+        string_stmt = string_program.statements[0]
+        assert isinstance(string_stmt, ast.ExpressionStatement)
+        assert isinstance(string_stmt.expression, ast.StringLiteral)
+
+    def test_url_in_set_statement(self) -> None:
+        """Test using a URL literal in a set statement."""
+        source = 'Set `api_endpoint` to _"https://api.example.com/v1"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.SetStatement)
+        assert stmt.name is not None
+        assert stmt.name.value == "api_endpoint"
+        assert isinstance(stmt.value, ast.URLLiteral)
+        assert stmt.value.value == "https://api.example.com/v1"
+
+    def test_url_with_port(self) -> None:
+        """Test parsing URL with port number."""
+        source = '_"http://localhost:8080/api"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "http://localhost:8080/api"
+
+    def test_data_url(self) -> None:
+        """Test parsing data URL."""
+        source = '_"data:text/plain;base64,SGVsbG8="_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        assert isinstance(stmt.expression, ast.URLLiteral)
+        assert stmt.expression.value == "data:text/plain;base64,SGVsbG8="
+
+    def test_multiple_urls_in_program(self) -> None:
+        """Test parsing multiple URLs in a program."""
+        source = """
+        Set `primary` to _"https://primary.example.com"_.
+        Set `secondary` to _"https://secondary.example.com"_.
+        Set `message` to _"Hello, World!"_.
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 3
+
+        # First statement - URL
+        stmt1 = program.statements[0]
+        assert isinstance(stmt1, ast.SetStatement)
+        assert isinstance(stmt1.value, ast.URLLiteral)
+        assert stmt1.value.value == "https://primary.example.com"
+
+        # Second statement - URL
+        stmt2 = program.statements[1]
+        assert isinstance(stmt2, ast.SetStatement)
+        assert isinstance(stmt2.value, ast.URLLiteral)
+        assert stmt2.value.value == "https://secondary.example.com"
+
+        # Third statement - Regular string
+        stmt3 = program.statements[2]
+        assert isinstance(stmt3, ast.SetStatement)
+        assert isinstance(stmt3.value, ast.StringLiteral)
+        assert stmt3.value.value == "Hello, World!"
+
+    def test_url_string_representation(self) -> None:
+        """Test the string representation of URL literals."""
+        source = '_"https://example.com"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+
+        # The string representation should use underscore syntax
+        assert str(stmt.expression) == '_"https://example.com"_'
+
+    def test_url_in_call_statement(self) -> None:
+        """Test using a URL literal as an argument in a use statement."""
+        source = 'Use `fetch` with _"https://api.example.com/data"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.CallStatement)
+        assert stmt.function_name is not None
+        assert isinstance(stmt.function_name, ast.Identifier)
+        assert stmt.function_name.value == "fetch"
+        assert stmt.arguments is not None
+        assert isinstance(stmt.arguments, ast.Arguments)
+        assert len(stmt.arguments.positional) == 1
+        assert isinstance(stmt.arguments.positional[0], ast.URLLiteral)
+        assert stmt.arguments.positional[0].value == "https://api.example.com/data"
+
+    def test_url_without_scheme_is_string(self) -> None:
+        """Test that URLs without schemes are parsed as regular strings."""
+        source = '_"example.com"_.'
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert program is not None
+        assert len(program.statements) == 1
+
+        stmt = program.statements[0]
+        assert isinstance(stmt, ast.ExpressionStatement)
+        # Without a scheme, it should be a StringLiteral, not URLLiteral
+        assert isinstance(stmt.expression, ast.StringLiteral)
+        assert stmt.expression.value == "example.com"