machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_call_statements_errors.py

@@ -0,0 +1,187 @@
+"""Tests for error handling in use statements."""
+
+from machine_dialect.ast import Arguments, CallStatement
+from machine_dialect.parser import Parser
+
+
+class TestCallStatementErrors:
+    """Test error handling for use statements."""
+
+    def test_call_missing_function_name(self) -> None:
+        """Test that use without function name produces an error."""
+        source = 'use with _"test"_.'
+
+        parser = Parser()
+        parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any(
+            ("expected identifier" in msg and "function name" in msg) or ("identifier" in msg and "got" in msg)
+            for msg in error_messages
+        ), f"Expected error about missing function name, got: {parser.errors}"
+
+    def test_call_with_invalid_function_name_type(self) -> None:
+        """Test that use with non-identifier function name produces an error."""
+        source = 'use _"not_an_identifier"_ with _"test"_.'
+
+        parser = Parser()
+        parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any("expected identifier" in msg or "function name" in msg for msg in error_messages), (
+            f"Expected error about invalid function name type, got: {parser.errors}"
+        )
+
+    def test_call_without_period(self) -> None:
+        """Test that use statement without period produces an error."""
+        source = "use `my_function`"
+
+        parser = Parser()
+        parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any("period" in msg or "punct_period" in msg for msg in error_messages), (
+            f"Expected error about missing period, got: {parser.errors}"
+        )
+
+    def test_call_with_invalid_argument_value(self) -> None:
+        """Test that use with truly invalid argument value produces an error."""
+        source = "use `my_function` with @#$."
+
+        parser = Parser()
+        parser.parse(source, check_semantics=False)
+
+        # Should have an error about invalid argument
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any("invalid" in msg or "no suitable parse function" in msg for msg in error_messages), (
+            f"Expected error about invalid argument, got: {parser.errors}"
+        )
+
+    def test_call_with_missing_comma_between_positional_args(self) -> None:
+        """Test that missing comma between arguments produces an error."""
+        source = 'use `my_function` with `param` _"value"_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should have an error about missing comma
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any("comma" in msg or "unexpected" in msg for msg in error_messages), (
+            f"Expected error about missing comma, got: {parser.errors}"
+        )
+
+        # Should still parse both arguments (error recovery)
+        assert len(program.statements) == 1
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        if call_stmt.arguments:
+            # Should have parsed both as positional arguments despite the error
+            assert isinstance(call_stmt.arguments, Arguments)
+            assert len(call_stmt.arguments.positional) == 2
+
+    def test_call_with_empty_arguments(self) -> None:
+        """Test that use with 'with' but no arguments produces reasonable behavior."""
+        source = "use `my_function` with ."
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # This should either produce an error or create an empty arguments list
+        if len(parser.errors) > 0:
+            # If errors, should be about missing arguments
+            error_messages = [str(err).lower() for err in parser.errors]
+            assert any("invalid" in msg or "expected" in msg for msg in error_messages)
+        else:
+            # If no errors, should have empty arguments
+            assert len(program.statements) == 1
+            call_stmt = program.statements[0]
+            assert isinstance(call_stmt, CallStatement)
+            assert call_stmt.arguments is not None
+            assert isinstance(call_stmt.arguments, Arguments)
+            assert len(call_stmt.arguments.positional) == 0
+            assert len(call_stmt.arguments.named) == 0
+
+    def test_call_with_duplicate_named_arguments(self) -> None:
+        """Test behavior with duplicate named argument keys."""
+        source = 'use `my_function` where `param` is _"value1"_, `param` is _"value2"_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Parser currently doesn't check for duplicates, so this should parse successfully
+        # but both values should be present
+        assert len(parser.errors) == 0, f"Unexpected errors: {parser.errors}"
+        assert len(program.statements) == 1
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        assert call_stmt.arguments is not None
+        assert isinstance(call_stmt.arguments, Arguments)
+        assert len(call_stmt.arguments.named) == 2
+        # Both should have the same name
+        name1, _ = call_stmt.arguments.named[0]
+        name2, _ = call_stmt.arguments.named[1]
+        assert name1.value == "param"
+        assert name2.value == "param"
+
+    def test_call_with_missing_comma_between_arguments(self) -> None:
+        """Test that missing comma between arguments produces an error."""
+        source = 'use `my_function` with _"arg1"_ _"arg2"_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should produce an error about missing comma
+        assert len(parser.errors) > 0
+        error_messages = [str(err).lower() for err in parser.errors]
+        assert any("comma" in msg or "unexpected" in msg for msg in error_messages), (
+            f"Expected error about missing comma, got: {parser.errors}"
+        )
+
+        # With error recovery, it should still parse both arguments
+        assert len(program.statements) == 1
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        if call_stmt.arguments:
+            # Should have parsed both arguments (with error recovery)
+            assert isinstance(call_stmt.arguments, Arguments)
+            assert len(call_stmt.arguments.positional) == 2
+
+    def test_call_with_trailing_comma(self) -> None:
+        """Test that trailing comma in arguments is handled gracefully."""
+        source = 'use `my_function` with _"arg1"_, _"arg2"_,.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Trailing comma should be acceptable or produce a clear error
+        if len(parser.errors) == 0:
+            assert len(program.statements) == 1
+            call_stmt = program.statements[0]
+            assert isinstance(call_stmt, CallStatement)
+            assert call_stmt.arguments is not None
+            assert isinstance(call_stmt.arguments, Arguments)
+            assert len(call_stmt.arguments.positional) == 2
+
+    def test_call_with_mixed_valid_and_invalid_arguments(self) -> None:
+        """Test error recovery with mixed valid and invalid arguments."""
+        # Note: 'invalid' without backticks is actually a valid identifier argument
+        # To test truly invalid syntax, we need something that's not a valid token
+        source = 'use `my_function` with _"valid"_, , _42_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # The double comma should cause parsing issues
+        # Parser should handle this gracefully
+        assert len(program.statements) == 1
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        # Should have parsed the valid arguments
+        if call_stmt.arguments:
+            assert isinstance(call_stmt.arguments, Arguments)
+            assert len(call_stmt.arguments.positional) >= 1  # At least the first valid one

machine_dialect/parser/tests/test_collection_mutations.py

@@ -0,0 +1,264 @@
+"""Test collection mutation statements in Machine Dialect™."""
+
+from machine_dialect.ast import (
+    Identifier,
+    SetStatement,
+    UnorderedListLiteral,
+    WholeNumberLiteral,
+)
+from machine_dialect.ast.statements import CollectionMutationStatement
+from machine_dialect.parser import Parser
+
+
+class TestCollectionMutations:
+    """Test parsing of collection mutation operations."""
+
+    def test_add_to_list(self) -> None:
+        """Test Add operation on lists."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to blank.
+Add _4_ to `items`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Check Add statement
+        add_stmt = program.statements[2]
+        assert isinstance(add_stmt, CollectionMutationStatement)
+        assert add_stmt.operation == "add"
+        assert isinstance(add_stmt.collection, Identifier)
+        assert add_stmt.collection.value == "items"
+        assert isinstance(add_stmt.value, WholeNumberLiteral)
+        assert add_stmt.value.value == 4
+
+    def test_remove_from_list(self) -> None:
+        """Test Remove operation on lists."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to:
+- _2_.
+Remove _2_ from `items`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Check Remove statement
+        remove_stmt = program.statements[2]
+        assert isinstance(remove_stmt, CollectionMutationStatement)
+        assert remove_stmt.operation == "remove"
+        assert isinstance(remove_stmt.collection, Identifier)
+        assert remove_stmt.collection.value == "items"
+        assert isinstance(remove_stmt.value, WholeNumberLiteral)
+        assert remove_stmt.value.value == 2
+
+    def test_set_item_with_ordinal(self) -> None:
+        """Test Set item using ordinal (first, second, third)."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to:
+- _1_.
+- _2_.
+Set the first item of `items` to _10_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Check Set item statement
+        set_stmt = program.statements[2]
+        assert isinstance(set_stmt, CollectionMutationStatement)
+        assert set_stmt.operation == "set"
+        assert isinstance(set_stmt.collection, Identifier)
+        assert set_stmt.collection.value == "items"
+        assert isinstance(set_stmt.value, WholeNumberLiteral)
+        assert set_stmt.value.value == 10
+        assert set_stmt.position == "first"
+        assert set_stmt.position_type == "ordinal"
+
+    def test_set_item_with_numeric_index(self) -> None:
+        """Test Set item using numeric index."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to:
+- _1_.
+- _2_.
+- _3_.
+Set item _2_ of `items` to _20_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Check Set item statement
+        set_stmt = program.statements[2]
+        assert isinstance(set_stmt, CollectionMutationStatement)
+        assert set_stmt.operation == "set"
+        assert isinstance(set_stmt.collection, Identifier)
+        assert set_stmt.collection.value == "items"
+        assert isinstance(set_stmt.value, WholeNumberLiteral)
+        assert set_stmt.value.value == 20
+        # Position should be the parsed expression
+        assert isinstance(set_stmt.position, WholeNumberLiteral)
+        assert set_stmt.position.value == 2
+        assert set_stmt.position_type == "numeric"
+
+    def test_insert_at_position(self) -> None:
+        """Test Insert operation at specific position."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to:
+- _1_.
+- _3_.
+Insert _15_ at position _2_ in `items`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Check Insert statement
+        insert_stmt = program.statements[2]
+        assert isinstance(insert_stmt, CollectionMutationStatement)
+        assert insert_stmt.operation == "insert"
+        assert isinstance(insert_stmt.collection, Identifier)
+        assert insert_stmt.collection.value == "items"
+        assert isinstance(insert_stmt.value, WholeNumberLiteral)
+        assert insert_stmt.value.value == 15
+        assert isinstance(insert_stmt.position, WholeNumberLiteral)
+        assert insert_stmt.position.value == 2
+        assert insert_stmt.position_type == "numeric"
+
+    def test_multiple_ordinals(self) -> None:
+        """Test multiple ordinal Set operations."""
+        source = """
+Define `items` as Ordered List.
+Set `items` to:
+1. _1_.
+2. _2_.
+3. _3_.
+4. _4_.
+Set the first item of `items` to _100_.
+Set the second item of `items` to _200_.
+Set the third item of `items` to _300_.
+Set the last item of `items` to _999_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 6
+
+        # Check each Set statement
+        ordinals = ["first", "second", "third", "last"]
+        values = [100, 200, 300, 999]
+
+        for i, (ordinal, value) in enumerate(zip(ordinals, values, strict=True), 2):
+            set_stmt = program.statements[i]
+            assert isinstance(set_stmt, CollectionMutationStatement)
+            assert set_stmt.operation == "set"
+            assert set_stmt.position == ordinal
+            assert set_stmt.position_type == "ordinal"
+            assert isinstance(set_stmt.value, WholeNumberLiteral)
+            assert isinstance(set_stmt.value, WholeNumberLiteral)
+            assert set_stmt.value.value == value
+
+    def test_keywords_as_identifiers(self) -> None:
+        """Test that keywords can be used as variable names in collection contexts."""
+        source = """
+Define `first` as Unordered List.
+Set `first` to blank.
+Add _1_ to `first`.
+Define `items` as Unordered List.
+Set `items` to blank.
+Add _2_ to `items`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 6
+
+        # Check that both 'first' (a keyword) and 'items' work as identifiers
+        add_stmt1 = program.statements[2]
+        assert isinstance(add_stmt1, CollectionMutationStatement)
+        assert isinstance(add_stmt1.collection, Identifier)
+        assert add_stmt1.collection.value == "first"
+
+        add_stmt2 = program.statements[5]
+        assert isinstance(add_stmt2, CollectionMutationStatement)
+        assert isinstance(add_stmt2.collection, Identifier)
+        assert add_stmt2.collection.value == "items"
+
+    def test_set_without_the(self) -> None:
+        """Test that 'Set first item of' works without 'the'."""
+        source = """
+Define `items` as Unordered List.
+Set `items` to:
+- _1_.
+- _2_.
+Set first item of `items` to _10_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # Should parse the same as "Set the first item of"
+        set_stmt = program.statements[2]
+        assert isinstance(set_stmt, CollectionMutationStatement)
+        assert set_stmt.operation == "set"
+        assert set_stmt.position == "first"
+        assert set_stmt.position_type == "ordinal"
+
+    def test_complex_mutation_sequence(self) -> None:
+        """Test a complex sequence of list mutations."""
+        source = """
+Define `shopping` as Unordered List.
+Set `shopping` to:
+- _"milk"_.
+- _"bread"_.
+- _"eggs"_.
+
+Add _"butter"_ to `shopping`.
+Remove _"bread"_ from `shopping`.
+Set the first item of `shopping` to _"oat milk"_.
+Insert _"cheese"_ at position _2_ in `shopping`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 6
+
+        # Verify the initial list
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+        assert isinstance(set_stmt.value, UnorderedListLiteral)
+        assert len(set_stmt.value.elements) == 3
+
+        # Verify each mutation
+        mutations = program.statements[2:]
+        assert all(isinstance(stmt, CollectionMutationStatement) for stmt in mutations)
+
+        # Check operations
+        assert isinstance(mutations[0], CollectionMutationStatement)
+        assert isinstance(mutations[1], CollectionMutationStatement)
+        assert isinstance(mutations[2], CollectionMutationStatement)
+        assert isinstance(mutations[3], CollectionMutationStatement)
+        assert mutations[0].operation == "add"
+        assert mutations[1].operation == "remove"
+        assert mutations[2].operation == "set"
+        assert mutations[3].operation == "insert"