machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_define_statements.py

@@ -0,0 +1,311 @@
+from machine_dialect.ast import DefineStatement
+from machine_dialect.parser import Parser
+
+
+class TestDefineStatements:
+    """Test parsing of Define statements."""
+
+    def test_parse_simple_define(self) -> None:
+        """Test parsing basic Define statement."""
+        source = "Define `count` as Whole Number."
+        parser = Parser()
+
+        # Debug: Add print before parsing
+        from machine_dialect.lexer import Lexer
+
+        lexer = Lexer(source)
+        tokens = []
+        while True:
+            tok = lexer.next_token()
+            tokens.append(tok)
+            if tok.type.name == "MISC_EOF":
+                break
+        print(f"Tokens: {[(t.type.name, t.literal) for t in tokens]}")
+
+        program = parser.parse(source)
+
+        # Debug: Print any parser errors
+        if parser.errors:
+            for error in parser.errors:
+                print(f"Parser error: {error}")
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "count"
+        assert stmt.type_spec == ["Whole Number"]
+        assert stmt.initial_value is None
+
+    def test_parse_define_with_default(self) -> None:
+        """Test parsing Define with default value."""
+        source = 'Define `message` as Text (default: _"Hello World"_).'
+
+        # Debug: Print tokens first
+        from machine_dialect.lexer import Lexer
+
+        lexer = Lexer(source)
+        tokens = []
+        while True:
+            tok = lexer.next_token()
+            tokens.append(tok)
+            if tok.type.name == "MISC_EOF":
+                break
+        print(f"Tokens: {[(t.type.name, t.literal) for t in tokens]}")
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        # Debug: Print statements
+        print(f"Got {len(program.statements)} statements:")
+        for i, stmt in enumerate(program.statements):
+            print(f"  {i}: {type(stmt).__name__}: {stmt}")
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "message"
+        assert stmt.type_spec == ["Text"]
+        assert stmt.initial_value is not None
+        assert str(stmt.initial_value) == '_"Hello World"_'
+
+    def test_parse_define_with_integer_default(self) -> None:
+        """Test parsing Define with integer default."""
+        source = "Define `age` as Whole Number (default: _25_)."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "age"
+        assert stmt.type_spec == ["Whole Number"]
+        assert str(stmt.initial_value) == "_25_"
+
+    def test_parse_define_with_boolean_default(self) -> None:
+        """Test parsing Define with boolean default."""
+        source = "Define `is_active` as Yes/No (default: _yes_)."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "is_active"
+        assert stmt.type_spec == ["Yes/No"]
+        assert str(stmt.initial_value) == "_Yes_"
+
+    def test_parse_union_type(self) -> None:
+        """Test parsing Define with union types."""
+        source = "Define `value` as Whole Number or Text."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "value"
+        assert stmt.type_spec == ["Whole Number", "Text"]
+
+    def test_parse_multiple_union_types(self) -> None:
+        """Test parsing Define with multiple union types."""
+        source = "Define `data` as Number or Yes/No or Text or Empty."
+
+        # Debug: Check tokens
+        from machine_dialect.lexer import Lexer
+
+        lexer = Lexer(source)
+        tokens = []
+        while True:
+            tok = lexer.next_token()
+            tokens.append(tok)
+            if tok.type.name == "MISC_EOF":
+                break
+        print(f"Tokens: {[(t.type.name, t.literal) for t in tokens]}")
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        print(f"Got type_spec: {stmt.type_spec}")
+        assert stmt.type_spec == ["Number", "Yes/No", "Text", "Empty"]
+
+    def test_parse_various_type_names(self) -> None:
+        """Test parsing various type names."""
+        test_cases = [
+            ("Define `a` as Text.", ["Text"]),
+            ("Define `b` as Whole Number.", ["Whole Number"]),
+            ("Define `c` as Float.", ["Float"]),
+            ("Define `d` as Number.", ["Number"]),
+            ("Define `e` as Yes/No.", ["Yes/No"]),
+            ("Define `f` as URL.", ["URL"]),
+            ("Define `g` as Date.", ["Date"]),
+            ("Define `h` as DateTime.", ["DateTime"]),
+            ("Define `i` as Time.", ["Time"]),
+            ("Define `j` as List.", ["List"]),
+            ("Define `k` as Empty.", ["Empty"]),
+        ]
+
+        for source, expected_types in test_cases:
+            parser = Parser()
+            program = parser.parse(source)
+            assert len(program.statements) == 1
+            stmt = program.statements[0]
+            assert isinstance(stmt, DefineStatement)
+            assert stmt.type_spec == expected_types
+
+    def test_error_missing_variable_name(self) -> None:
+        """Test error when variable name is missing."""
+        source = "Define as Whole Number."
+        parser = Parser()
+        _ = parser.parse(source)
+
+        assert len(parser.errors) > 0
+        # The error message or structure may vary, just check we got errors
+
+    def test_error_missing_as_keyword(self) -> None:
+        """Test error when 'as' keyword is missing."""
+        source = "Define `count` Whole Number."
+        parser = Parser()
+        _ = parser.parse(source)
+
+        assert len(parser.errors) > 0
+
+    def test_error_missing_type(self) -> None:
+        """Test error when type is missing."""
+        source = "Define `count` as."
+        parser = Parser()
+        _ = parser.parse(source)
+
+        assert len(parser.errors) > 0
+
+    def test_error_invalid_default_syntax(self) -> None:
+        """Test error with invalid default syntax."""
+        source = "Define `x` as Whole Number (default _5_)."  # Missing colon
+        parser = Parser()
+        _ = parser.parse(source)
+
+        assert len(parser.errors) > 0
+
+    def test_define_with_stopwords(self) -> None:
+        """Test that stopwords are properly skipped."""
+        source = "Define the `count` as a Whole Number."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, DefineStatement)
+        assert stmt.name.value == "count"
+        assert stmt.type_spec == ["Whole Number"]
+
+    def test_multiple_define_statements(self) -> None:
+        """Test parsing multiple Define statements."""
+        source = """
+Define `name` as Text.
+Define `age` as Whole Number.
+Define `active` as Yes/No (default: _yes_).
+        """
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 3
+
+        # Check first statement
+        stmt1 = program.statements[0]
+        assert isinstance(stmt1, DefineStatement)
+        assert stmt1.name.value == "name"
+        assert stmt1.type_spec == ["Text"]
+        assert stmt1.initial_value is None
+
+        # Check second statement
+        stmt2 = program.statements[1]
+        assert isinstance(stmt2, DefineStatement)
+        assert stmt2.name.value == "age"
+        assert stmt2.type_spec == ["Whole Number"]
+        assert stmt2.initial_value is None
+
+        # Check third statement
+        stmt3 = program.statements[2]
+        assert isinstance(stmt3, DefineStatement)
+        assert stmt3.name.value == "active"
+        assert stmt3.type_spec == ["Yes/No"]
+        assert stmt3.initial_value is not None
+
+    def test_complex_nested_default_expressions(self) -> None:
+        """Test parsing Define with complex nested default expressions."""
+        # Test arithmetic expression as default
+        source1 = "Define `result` as Number (default: _70_)."
+        parser1 = Parser()
+        program1 = parser1.parse(source1)
+        assert len(program1.statements) == 1
+        stmt1 = program1.statements[0]
+        assert isinstance(stmt1, DefineStatement)
+        assert stmt1.name.value == "result"
+        assert stmt1.type_spec == ["Number"]
+        assert stmt1.initial_value is not None
+
+        # Test string literal as default
+        source2 = 'Define `value` as Text (default: _"Hello World"_).'
+        parser2 = Parser()
+        program2 = parser2.parse(source2)
+        assert len(program2.statements) == 1
+        stmt2 = program2.statements[0]
+        assert isinstance(stmt2, DefineStatement)
+        assert stmt2.initial_value is not None
+
+        # Test boolean expression as default
+        source3 = "Define `flag` as Yes/No (default: _yes_)."
+        parser3 = Parser()
+        program3 = parser3.parse(source3)
+        assert len(program3.statements) == 1
+        stmt3 = program3.statements[0]
+        assert isinstance(stmt3, DefineStatement)
+        assert stmt3.type_spec == ["Yes/No"]
+        assert stmt3.initial_value is not None
+
+    def test_error_recovery_paths(self) -> None:
+        """Test error recovery when parsing malformed Define statements."""
+        # Missing closing parenthesis in default
+        source1 = "Define `x` as Number (default: _5_. Define `y` as Text."
+        parser1 = Parser()
+        _ = parser1.parse(source1)
+        # Should have errors but still parse the second Define
+        assert len(parser1.errors) > 0
+        # May still have some statements parsed
+
+        # Malformed type specification
+        source2 = "Define `z` as or Text."
+        parser2 = Parser()
+        _ = parser2.parse(source2)
+        assert len(parser2.errors) > 0
+
+        # Multiple errors in one statement
+        source3 = "Define as (default: )."
+        parser3 = Parser()
+        _ = parser3.parse(source3)
+        assert len(parser3.errors) > 0
+
+    def test_edge_case_union_types(self) -> None:
+        """Test edge cases for union type specifications."""
+        # Very long union type list
+        source1 = "Define `data` as Text or Number or Yes/No or Date or Time or URL or List or Empty."
+        parser1 = Parser()
+        program1 = parser1.parse(source1)
+        assert len(program1.statements) == 1
+        stmt1 = program1.statements[0]
+        assert isinstance(stmt1, DefineStatement)
+        assert len(stmt1.type_spec) == 8
+        assert "Text" in stmt1.type_spec
+        assert "Empty" in stmt1.type_spec
+
+        # Union type with default value
+        source2 = "Define `flexible` as Text or Number (default: _42_)."
+        parser2 = Parser()
+        program2 = parser2.parse(source2)
+        assert len(program2.statements) == 1
+        stmt2 = program2.statements[0]
+        assert isinstance(stmt2, DefineStatement)
+        assert stmt2.type_spec == ["Text", "Number"]
+        assert stmt2.initial_value is not None

machine_dialect/parser/tests/test_dict_extraction.py

@@ -0,0 +1,115 @@
+"""Tests for dictionary keys/values extraction parsing."""
+
+from machine_dialect.ast.dict_extraction import DictExtraction
+from machine_dialect.ast.expressions import Identifier
+from machine_dialect.ast.statements import SetStatement
+from machine_dialect.lexer.tokens import Token, TokenType
+from machine_dialect.parser.parser import Parser
+
+
+class TestDictExtraction:
+    """Test parsing of dictionary extraction expressions."""
+
+    def test_parse_names_extraction(self) -> None:
+        """Test parsing 'the names of `dict`'."""
+        source = "Set `result` to the names of `person`."
+        parser = Parser()
+        program = parser.parse(source)
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, SetStatement)  # Type assertion for MyPy
+        expr = stmt.value
+        assert isinstance(expr, DictExtraction)
+        assert expr.extract_type == "names"
+        assert isinstance(expr.dictionary, Identifier)
+        assert expr.dictionary.value == "person"
+        assert str(expr) == "the names of `person`"
+
+    def test_parse_contents_extraction(self) -> None:
+        """Test parsing 'the contents of `dict`'."""
+        source = "Set `result` to the contents of `config`."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert isinstance(stmt, SetStatement)  # Type assertion for MyPy
+        expr = stmt.value
+
+        assert isinstance(expr, DictExtraction)
+        assert expr.extract_type == "contents"
+        assert isinstance(expr.dictionary, Identifier)
+        assert expr.dictionary.value == "config"
+        assert str(expr) == "the contents of `config`"
+
+    def test_parse_names_in_set_statement(self) -> None:
+        """Test parsing 'Set `names` to the names of `person`.'"""
+        source = "Set `my_names` to the names of `person`."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert stmt.__class__.__name__ == "SetStatement"
+        assert isinstance(stmt, SetStatement)  # Type assertion for MyPy
+
+        # Check the value is a DictExtraction
+        assert isinstance(stmt.value, DictExtraction)
+        assert stmt.value.extract_type == "names"
+        dict_val = stmt.value.dictionary
+        assert isinstance(dict_val, Identifier)
+        assert dict_val.value == "person"
+
+    def test_parse_contents_in_set_statement(self) -> None:
+        """Test parsing 'Set `values` to the contents of `dict`.'"""
+        source = "Set `my_values` to the contents of `settings`."
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        assert stmt.__class__.__name__ == "SetStatement"
+        assert isinstance(stmt, SetStatement)  # Type assertion for MyPy
+
+        # Check the value is a DictExtraction
+        assert isinstance(stmt.value, DictExtraction)
+        assert stmt.value.extract_type == "contents"
+        dict_val = stmt.value.dictionary
+        assert isinstance(dict_val, Identifier)
+        assert dict_val.value == "settings"
+
+    def test_parse_invalid_extraction_missing_dict(self) -> None:
+        """Test error when dictionary is missing."""
+        source = "Set `result` to the names of."
+        parser = Parser()
+        program = parser.parse(source)
+
+        # The parser should handle the missing dictionary gracefully
+        assert len(program.statements) == 1
+        stmt = program.statements[0]
+        # The value might be an error expression or partial parse
+        assert stmt is not None
+
+    def test_dict_extraction_to_hir(self) -> None:
+        """Test that DictExtraction converts to HIR properly."""
+        token = Token(TokenType.MISC_STOPWORD, "the", 1, 1)
+        dict_ident = Identifier(Token(TokenType.MISC_IDENT, "person", 1, 5), "person")
+
+        extraction = DictExtraction(token, dict_ident, "names")
+        hir = extraction.to_hir()
+
+        assert isinstance(hir, DictExtraction)
+        assert hir.extract_type == "names"
+        assert isinstance(hir.dictionary, Identifier)
+
+    def test_dict_extraction_desugar(self) -> None:
+        """Test that DictExtraction desugars properly."""
+        token = Token(TokenType.MISC_STOPWORD, "the", 1, 1)
+        dict_ident = Identifier(Token(TokenType.MISC_IDENT, "person", 1, 5), "person")
+
+        extraction = DictExtraction(token, dict_ident, "contents")
+        desugared = extraction.desugar()
+
+        assert isinstance(desugared, DictExtraction)
+        assert desugared.extract_type == "contents"
+        assert isinstance(desugared.dictionary, Identifier)

machine_dialect/parser/tests/test_empty_literal.py

@@ -0,0 +1,155 @@
+"""Tests for parsing the empty literal."""
+
+import pytest
+
+from machine_dialect.ast import EmptyLiteral, ExpressionStatement
+from machine_dialect.parser import Parser
+
+
+class TestEmptyLiteral:
+    """Test parsing of the empty literal."""
+
+    def test_parse_empty_literal(self) -> None:
+        """Test parsing the empty keyword as a literal."""
+        source = "empty"
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert isinstance(statement.expression, EmptyLiteral)
+        assert statement.expression.value is None
+        assert str(statement.expression) == "empty"
+
+    def test_empty_in_set_statement(self) -> None:
+        """Test using empty in a set statement."""
+        source = """Define `result` as Empty.
+Set `result` to empty."""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        from machine_dialect.ast import DefineStatement, SetStatement
+
+        # Check Define statement
+        assert isinstance(program.statements[0], DefineStatement)
+
+        # Check Set statement
+        statement = program.statements[1]
+        assert isinstance(statement, SetStatement)
+        assert isinstance(statement.value, EmptyLiteral)
+
+    def test_empty_in_comparison(self) -> None:
+        """Test using empty in comparison expressions."""
+        test_cases = [
+            ("x equals empty", "`x`", "equals", "empty"),
+            ("`value` is not empty", "`value`", "is not", "empty"),
+            ("result is strictly equal to empty", "`result`", "is strictly equal to", "empty"),
+        ]
+
+        for source, expected_left, expected_op, expected_right 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)
+
+            from machine_dialect.ast import InfixExpression
+
+            expr = statement.expression
+            assert isinstance(expr, InfixExpression)
+            assert str(expr.left) == expected_left
+            assert expr.operator == expected_op
+            assert str(expr.right) == expected_right
+
+    def test_empty_in_if_condition(self) -> None:
+        """Test using empty in if statement conditions."""
+        source = """
+        Define `value` as Whole Number or Empty.
+        Define `result` as Whole Number.
+        if `value` equals empty then:
+        > Set `result` to _0_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        from machine_dialect.ast import DefineStatement, IfStatement, InfixExpression
+
+        # Check Define statements
+        assert isinstance(program.statements[0], DefineStatement)
+        assert isinstance(program.statements[1], DefineStatement)
+
+        # Check If statement
+        if_stmt = program.statements[2]
+        assert isinstance(if_stmt, IfStatement)
+        assert isinstance(if_stmt.condition, InfixExpression)
+        assert str(if_stmt.condition.right) == "empty"
+
+    def test_empty_in_return_statement(self) -> None:
+        """Test using empty in a return statement."""
+        source = "give back empty."
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        from machine_dialect.ast import ReturnStatement
+
+        statement = program.statements[0]
+        assert isinstance(statement, ReturnStatement)
+        assert isinstance(statement.return_value, EmptyLiteral)
+
+    def test_empty_not_confused_with_identifier(self) -> None:
+        """Test that 'empty' is recognized as a keyword, not an identifier."""
+        # Test that 'empty' is parsed as EmptyLiteral
+        parser1 = Parser()
+        program1 = parser1.parse("empty", check_semantics=False)
+        assert len(parser1.errors) == 0
+        stmt1 = program1.statements[0]
+        assert isinstance(stmt1, ExpressionStatement)
+        assert isinstance(stmt1.expression, EmptyLiteral)
+
+        # Test that similar words are parsed as identifiers
+        parser2 = Parser()
+        program2 = parser2.parse("empties", check_semantics=False)
+        assert len(parser2.errors) == 0
+
+        from machine_dialect.ast import Identifier
+
+        stmt2 = program2.statements[0]
+        assert isinstance(stmt2, ExpressionStatement)
+        assert isinstance(stmt2.expression, Identifier)
+
+    @pytest.mark.parametrize(
+        "source",
+        [
+            "Empty",  # Different case
+            "EMPTY",  # All caps
+            "eMpTy",  # Mixed case
+        ],
+    )
+    def test_empty_case_insensitive(self, source: str) -> None:
+        """Test that empty keyword is case-insensitive."""
+        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 isinstance(statement.expression, EmptyLiteral)
+        # String representation should always be lowercase
+        assert str(statement.expression) == "empty"