machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/ast/tests/test_ast_string_representation.py

@@ -0,0 +1,62 @@
+from machine_dialect.ast import Identifier, Program, ReturnStatement, SetStatement, WholeNumberLiteral
+from machine_dialect.lexer import Token, TokenType
+
+
+class TestASTStringRepresentation:
+    def test_set_statement_string(self) -> None:
+        program: Program = Program(
+            statements=[
+                SetStatement(
+                    token=Token(TokenType.KW_SET, "Set", 1, 0),
+                    name=Identifier(token=Token(TokenType.MISC_IDENT, "my_var", 1, 4), value="my_var"),
+                    value=Identifier(
+                        token=Token(TokenType.MISC_IDENT, "other_var", 1, 15),
+                        value="other_var",
+                    ),
+                )
+            ]
+        )
+
+        program_str = str(program)
+
+        assert program_str == "Set `my_var` to `other_var`.\n"
+
+    def test_return_statement_string(self) -> None:
+        program: Program = Program(
+            statements=[
+                ReturnStatement(
+                    token=Token(TokenType.KW_RETURN, "Give back", 1, 0),
+                    return_value=Identifier(token=Token(TokenType.MISC_IDENT, "my_var", 1, 7), value="my_var"),
+                )
+            ]
+        )
+
+        program_str = str(program)
+
+        assert program_str == "\nGive back `my_var`.\n"
+
+    def test_multiple_statements_string(self) -> None:
+        program: Program = Program(
+            statements=[
+                SetStatement(
+                    token=Token(TokenType.KW_SET, "Set", 1, 0),
+                    name=Identifier(token=Token(TokenType.MISC_IDENT, "x", 1, 4), value="x"),
+                    value=WholeNumberLiteral(token=Token(TokenType.LIT_WHOLE_NUMBER, "_42_", 1, 11), value=42),
+                ),
+                SetStatement(
+                    token=Token(TokenType.KW_SET, "Set", 2, 0),
+                    name=Identifier(token=Token(TokenType.MISC_IDENT, "result", 2, 4), value="result"),
+                    value=Identifier(token=Token(TokenType.MISC_IDENT, "x", 2, 11), value="x"),
+                ),
+                ReturnStatement(
+                    token=Token(TokenType.KW_RETURN, "Give back", 3, 0),
+                    return_value=Identifier(token=Token(TokenType.MISC_IDENT, "result", 3, 7), value="result"),
+                ),
+            ]
+        )
+
+        program_str = str(program)
+
+        # The Program concatenates statements with ".\n" and adds final ".\n"
+        expected = "Set `x` to _42_.\nSet `result` to `x`.\n\nGive back `result`.\n"
+        assert program_str == expected

machine_dialect/ast/tests/test_boolean_literal.py

@@ -0,0 +1,29 @@
+from machine_dialect.ast import YesNoLiteral
+from machine_dialect.lexer import Token, TokenType
+
+
+class TestBooleanLiteral:
+    def test_boolean_literal_true_display(self) -> None:
+        """Test that YesNoLiteral displays Yes with underscores."""
+        token = Token(TokenType.LIT_YES, "Yes", 1, 0)
+        literal = YesNoLiteral(token, True)
+
+        assert str(literal) == "_Yes_"
+
+    def test_boolean_literal_false_display(self) -> None:
+        """Test that YesNoLiteral displays No with underscores."""
+        token = Token(TokenType.LIT_NO, "No", 1, 0)
+        literal = YesNoLiteral(token, False)
+
+        assert str(literal) == "_No_"
+
+    def test_boolean_literal_value(self) -> None:
+        """Test that YesNoLiteral stores the correct boolean value."""
+        true_token = Token(TokenType.LIT_YES, "Yes", 1, 0)
+        true_literal = YesNoLiteral(true_token, True)
+
+        false_token = Token(TokenType.LIT_NO, "No", 1, 0)
+        false_literal = YesNoLiteral(false_token, False)
+
+        assert true_literal.value is True
+        assert false_literal.value is False

machine_dialect/ast/tests/test_collection_hir.py

@@ -0,0 +1,138 @@
+"""Test HIR generation for collection operations."""
+
+from machine_dialect.ast.expressions import CollectionAccessExpression, Identifier
+from machine_dialect.ast.literals import UnorderedListLiteral, WholeNumberLiteral
+from machine_dialect.ast.statements import CollectionMutationStatement
+from machine_dialect.lexer import Token, TokenType
+
+
+class TestCollectionHIR:
+    """Test HIR generation for collection operations."""
+
+    def test_list_literal_to_hir(self) -> None:
+        """Test that list literals convert to HIR properly."""
+        token = Token(TokenType.PUNCT_DASH, "-", 1, 1)
+        from machine_dialect.ast.expressions import Expression
+
+        elements: list[Expression] = [
+            WholeNumberLiteral(token, 1),
+            WholeNumberLiteral(token, 2),
+            WholeNumberLiteral(token, 3),
+        ]
+
+        unordered = UnorderedListLiteral(token, elements)
+        hir = unordered.to_hir()
+
+        assert isinstance(hir, UnorderedListLiteral)
+        assert len(hir.elements) == 3
+        assert all(isinstance(elem, WholeNumberLiteral) for elem in hir.elements)
+
+    def test_collection_access_ordinal_to_hir(self) -> None:
+        """Test that ordinal access converts to zero-based index."""
+        token = Token(TokenType.KW_FIRST, "first", 1, 1)
+        collection = Identifier(token, "items")
+
+        # Test "first" -> 0
+        access = CollectionAccessExpression(token, collection, "first", "ordinal")
+        hir = access.to_hir()
+
+        assert hir.accessor == 0
+        assert hir.access_type == "numeric"  # Changed from ordinal to numeric
+
+        # Test "second" -> 1
+        access = CollectionAccessExpression(token, collection, "second", "ordinal")
+        hir = access.to_hir()
+
+        assert hir.accessor == 1
+        assert hir.access_type == "numeric"
+
+        # Test "third" -> 2
+        access = CollectionAccessExpression(token, collection, "third", "ordinal")
+        hir = access.to_hir()
+
+        assert hir.accessor == 2
+        assert hir.access_type == "numeric"
+
+    def test_collection_access_numeric_to_hir(self) -> None:
+        """Test that numeric access converts from 1-based to 0-based."""
+        token = Token(TokenType.KW_ITEM, "item", 1, 1)
+        collection = Identifier(token, "items")
+
+        # Test numeric index: 1 -> 0
+        access = CollectionAccessExpression(token, collection, 1, "numeric")
+        hir = access.to_hir()
+
+        assert hir.accessor == 0  # 1-based to 0-based
+        assert hir.access_type == "numeric"
+
+        # Test larger index: 877 -> 876
+        access = CollectionAccessExpression(token, collection, 877, "numeric")
+        hir = access.to_hir()
+
+        assert hir.accessor == 876
+        assert hir.access_type == "numeric"
+
+    def test_collection_access_last_to_hir(self) -> None:
+        """Test that 'last' remains as special case."""
+        token = Token(TokenType.KW_LAST, "last", 1, 1)
+        collection = Identifier(token, "items")
+
+        access = CollectionAccessExpression(token, collection, "last", "ordinal")
+        hir = access.to_hir()
+
+        # "last" should remain as "last" for special handling in MIR
+        assert hir.accessor == "last"
+        assert hir.access_type == "ordinal"  # Keeps ordinal type for "last"
+
+    def test_collection_mutation_ordinal_to_hir(self) -> None:
+        """Test that mutation statements convert ordinals properly."""
+        token = Token(TokenType.KW_SET, "Set", 1, 1)
+        collection = Identifier(token, "items")
+        value = WholeNumberLiteral(token, 10)
+
+        # Test "Set the first item" -> index 0
+        mutation = CollectionMutationStatement(token, "set", collection, value, "first", "ordinal")
+        hir = mutation.to_hir()
+
+        assert hir.position == 0
+        assert hir.position_type == "numeric"  # Changed from ordinal
+
+        # Test "Set the second item" -> index 1
+        mutation = CollectionMutationStatement(token, "set", collection, value, "second", "ordinal")
+        hir = mutation.to_hir()
+
+        assert hir.position == 1
+        assert hir.position_type == "numeric"
+
+    def test_collection_mutation_numeric_to_hir(self) -> None:
+        """Test that mutation statements convert numeric indices."""
+        token = Token(TokenType.KW_SET, "Set", 1, 1)
+        collection = Identifier(token, "items")
+        value = WholeNumberLiteral(token, 20)
+
+        # Test "Set item 1" -> index 0
+        mutation = CollectionMutationStatement(token, "set", collection, value, 1, "numeric")
+        hir = mutation.to_hir()
+
+        assert hir.position == 0  # 1-based to 0-based
+        assert hir.position_type == "numeric"
+
+        # Test "Set item 42" -> index 41
+        mutation = CollectionMutationStatement(token, "set", collection, value, 42, "numeric")
+        hir = mutation.to_hir()
+
+        assert hir.position == 41
+        assert hir.position_type == "numeric"
+
+    def test_collection_mutation_insert_to_hir(self) -> None:
+        """Test that insert operations convert positions properly."""
+        token = Token(TokenType.KW_INSERT, "Insert", 1, 1)
+        collection = Identifier(token, "items")
+        value = WholeNumberLiteral(token, 15)
+
+        # Test "Insert at position 2" -> index 1
+        mutation = CollectionMutationStatement(token, "insert", collection, value, 2, "numeric")
+        hir = mutation.to_hir()
+
+        assert hir.position == 1  # 1-based to 0-based
+        assert hir.position_type == "numeric"

machine_dialect/ast/tests/test_define_statement.py

@@ -0,0 +1,142 @@
+from machine_dialect.ast import (
+    BlockStatement,
+    DefineStatement,
+    Identifier,
+    SetStatement,
+    StringLiteral,
+    WholeNumberLiteral,
+)
+from machine_dialect.lexer import Token, TokenType
+
+
+class TestDefineStatement:
+    """Test DefineStatement AST node."""
+
+    def test_simple_definition(self) -> None:
+        """Test basic variable definition without default."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "count", 1, 8), "count")
+        type_spec = ["Whole Number"]
+
+        stmt = DefineStatement(token, name, type_spec)
+
+        assert str(stmt) == "Define `count` as Whole Number."
+        assert stmt.initial_value is None
+        assert stmt.type_spec == ["Whole Number"]
+
+    def test_definition_with_default(self) -> None:
+        """Test variable definition with default value."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "message", 1, 8), "message")
+        type_spec = ["Text"]
+        default = StringLiteral(Token(TokenType.LIT_TEXT, '"Hello"', 1, 30), "Hello")
+
+        stmt = DefineStatement(token, name, type_spec, default)
+
+        assert str(stmt) == 'Define `message` as Text (default: _"Hello"_).'
+        assert stmt.initial_value == default
+
+    def test_union_type_definition(self) -> None:
+        """Test definition with union types."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "value", 1, 8), "value")
+        type_spec = ["Whole Number", "Text", "Yes/No"]
+
+        stmt = DefineStatement(token, name, type_spec)
+
+        assert str(stmt) == "Define `value` as Whole Number or Text or Yes/No."
+
+    def test_desugar_without_default(self) -> None:
+        """Test desugaring when no default value."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "x", 1, 8), "x")
+        type_spec = ["Whole Number"]
+
+        stmt = DefineStatement(token, name, type_spec)
+        desugared = stmt.desugar()
+
+        # Should return self when no default
+        assert desugared is stmt
+
+    def test_desugar_with_default(self) -> None:
+        """Test desugaring with default value."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "count", 1, 8), "count")
+        type_spec = ["Whole Number"]
+        default = WholeNumberLiteral(Token(TokenType.LIT_WHOLE_NUMBER, "0", 1, 30), 0)
+
+        stmt = DefineStatement(token, name, type_spec, default)
+        desugared = stmt.desugar()
+
+        # Should return a BlockStatement with Define and Set
+        assert isinstance(desugared, BlockStatement)
+        assert len(desugared.statements) == 2
+
+        # First statement should be Define without default
+        define_stmt = desugared.statements[0]
+        assert isinstance(define_stmt, DefineStatement)
+        assert define_stmt.initial_value is None
+        assert define_stmt.name.value == "count"
+        assert define_stmt.type_spec == ["Whole Number"]
+
+        # Second statement should be Set
+        set_stmt = desugared.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+        assert set_stmt.name is not None
+        assert set_stmt.name.value == "count"
+        assert set_stmt.value == default
+
+    def test_multiple_types_string_representation(self) -> None:
+        """Test string representation with multiple types."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "data", 1, 8), "data")
+        type_spec = ["Number", "Text", "Yes/No", "Empty"]
+
+        stmt = DefineStatement(token, name, type_spec)
+
+        assert str(stmt) == "Define `data` as Number or Text or Yes/No or Empty."
+
+    def test_all_type_names(self) -> None:
+        """Test that all supported type names work correctly."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+
+        type_names = [
+            "Text",
+            "Whole Number",
+            "Float",
+            "Number",
+            "Yes/No",
+            "URL",
+            "Date",
+            "DateTime",
+            "Time",
+            "List",
+            "Empty",
+        ]
+
+        for type_name in type_names:
+            name = Identifier(Token(TokenType.MISC_IDENT, "var", 1, 8), "var")
+            stmt = DefineStatement(token, name, [type_name])
+            assert str(stmt) == f"Define `var` as {type_name}."
+
+    def test_desugar_preserves_name_reference(self) -> None:
+        """Test that desugaring preserves the same name reference."""
+        token = Token(TokenType.KW_DEFINE, "Define", 1, 1)
+        name = Identifier(Token(TokenType.MISC_IDENT, "test", 1, 8), "test")
+        type_spec = ["Text"]
+        default = StringLiteral(Token(TokenType.LIT_TEXT, '"value"', 1, 30), "value")
+
+        stmt = DefineStatement(token, name, type_spec, default)
+        desugared = stmt.desugar()
+
+        assert isinstance(desugared, BlockStatement)
+        define_stmt = desugared.statements[0]
+        set_stmt = desugared.statements[1]
+
+        # Both statements should reference the same variable name
+        assert isinstance(define_stmt, DefineStatement)
+        assert isinstance(set_stmt, SetStatement)
+        assert isinstance(define_stmt.name, Identifier)
+        assert isinstance(set_stmt.name, Identifier)
+        assert define_stmt.name.value == "test"
+        assert set_stmt.name.value == "test"