machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/tests/integration/test_lists_and_dictionaries.py

@@ -0,0 +1,322 @@
+"""Integration tests for list and dictionary features."""
+
+import pytest
+
+from machine_dialect.parser.parser import Parser
+
+
+class TestListFeatures:
+    """Test list (array) features end-to-end."""
+
+    def test_one_based_indexing_literal(self) -> None:
+        """Test that item _1_ accesses the first element (index 0)."""
+        source = """
+Set `numbers` to:
+- _10_.
+- _20_.
+- _30_.
+
+Set `first` to item _1_ of `numbers`.
+Set `second` to item _2_ of `numbers`.
+Set `third` to item _3_ of `numbers`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should parse successfully
+        assert len(program.statements) == 4
+        # Don't check for errors since we're just testing syntax
+
+    def test_one_based_indexing_expression(self) -> None:
+        """Test that expression-based indices are handled correctly."""
+        source = """
+Set `idx` to _2_.
+Set `numbers` to:
+- _100_.
+- _200_.
+- _300_.
+
+Set `value` to item `idx` of `numbers`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should parse successfully
+        assert len(program.statements) == 3
+        # Don't check for errors since we're just testing syntax
+
+    def test_array_mutations_with_one_based_index(self) -> None:
+        """Test array mutations with one-based indexing."""
+        source = """
+Set `list` to:
+- _"a"_.
+- _"b"_.
+- _"c"_.
+
+Set item _1_ of `list` to _"A"_.
+Remove item _2_ from `list`.
+Insert _"X"_ at position _1_ in `list`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 4
+        # Don't check for errors since we're just testing syntax
+
+    def test_clear_operation(self) -> None:
+        """Test the Clear operation on lists."""
+        source = """
+Set `items` to:
+- _1_.
+- _2_.
+- _3_.
+
+Clear `items`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 2
+        # Don't check for errors since we're just testing syntax
+
+    def test_ordinal_access(self) -> None:
+        """Test ordinal access (first, second, third, last)."""
+        source = """
+Set `colors` to:
+- _"red"_.
+- _"green"_.
+- _"blue"_.
+- _"yellow"_.
+
+Set `f` to the first item of `colors`.
+Set `s` to the second item of `colors`.
+Set `t` to the third item of `colors`.
+Set `l` to the last item of `colors`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 5
+        # Don't check for errors since we're just testing syntax
+
+
+class TestDictionaryFeatures:
+    """Test dictionary (named list) features end-to-end."""
+
+    def test_named_list_creation(self) -> None:
+        """Test creating a named list (dictionary)."""
+        source = """
+Set `person` to:
+- _"name"_: _"Alice"_.
+- _"age"_: _30_.
+- _"email"_: _"alice@example.com"_.
+- _"active"_: _yes_.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 1
+        # Don't check for errors since we're just testing syntax
+
+    def test_dictionary_keys_extraction(self) -> None:
+        """Test extracting keys from a dictionary."""
+        source = """
+Set `config` to:
+- _"host"_: _"localhost"_.
+- _"port"_: _8080_.
+- _"debug"_: _yes_.
+
+Set `keys` to the names of `config`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 2
+        # Don't check for errors since we're just testing syntax
+
+    def test_dictionary_values_extraction(self) -> None:
+        """Test extracting values from a dictionary."""
+        source = """
+Set `user` to:
+- _"username"_: _"johndoe"_.
+- _"email"_: _"john@example.com"_.
+- _"premium"_: _yes_.
+
+Set `values` to the contents of `user`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 2
+        # Don't check for errors since we're just testing syntax
+
+    def test_possessive_property_access(self) -> None:
+        """Test possessive syntax for property access."""
+        source = """
+Set `person` to:
+- _"name"_: _"Bob"_.
+- _"age"_: _25_.
+- _"city"_: _"New York"_.
+
+Set `user_name` to `person`'s _"name"_.
+Set `user_age` to `person`'s _"age"_.
+Set `user_city` to `person`'s _"city"_.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 4
+        # Don't check for errors since we're just testing syntax
+
+    def test_possessive_property_mutation(self) -> None:
+        """Test modifying properties using possessive syntax."""
+        source = """
+Set `config` to:
+- _"host"_: _"localhost"_.
+- _"port"_: _8080_.
+
+Set `config`'s _"port"_ to _9000_.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # This should parse, though the exact handling may vary
+        assert len(program.statements) == 2
+        # Don't check for errors since we're just testing syntax
+
+    def test_dictionary_operations(self) -> None:
+        """Test various dictionary operations."""
+        source = """
+Set `data` to:
+- _"key1"_: _"value1"_.
+- _"key2"_: _"value2"_.
+
+Add _"key3"_ to `data` with value _"value3"_.
+Remove _"key1"_ from `data`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 3
+        # Don't check for errors since we're just testing syntax
+
+
+class TestNestedCollections:
+    """Test combinations of lists and dictionaries."""
+
+    @pytest.mark.skip(
+        reason="Nested collection structures not yet supported by parser - requires complex grammar changes"
+    )
+    def test_list_of_dictionaries(self) -> None:
+        """Test creating a list containing dictionaries."""
+        source = """
+Set `users` to:
+- - _"name"_: _"Alice"_.
+  - _"age"_: _30_.
+- - _"name"_: _"Bob"_.
+  - _"age"_: _25_.
+
+Set `first_user` to the first item of `users`.
+Set `first_name` to `first_user`'s _"name"_.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should parse the nested structure
+        assert len(program.statements) == 3
+
+    @pytest.mark.skip(
+        reason="Nested collection structures not yet supported by parser - requires complex grammar changes"
+    )
+    def test_dictionary_with_list_values(self) -> None:
+        """Test dictionary with lists as values."""
+        source = """
+Set `data` to:
+- _"numbers"_:
+  - _1_.
+  - _2_.
+  - _3_.
+- _"names"_:
+  - _"Alice"_.
+  - _"Bob"_.
+
+Set `nums` to `data`'s _"numbers"_.
+Set `first_num` to the first item of `nums`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should handle nested structures
+        assert len(program.statements) == 3
+
+    def test_extraction_and_access_combination(self) -> None:
+        """Test combining extraction with list access."""
+        source = """
+Set `config` to:
+- _"timeout"_: _30_.
+- _"retries"_: _3_.
+- _"debug"_: _no_.
+
+Set `keys` to the names of `config`.
+Set `values` to the contents of `config`.
+
+Set `first_key` to the first item of `keys`.
+Set `first_value` to the first item of `values`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 5
+        # Don't check for errors since we're just testing syntax
+
+
+class TestIndexingEdgeCases:
+    """Test edge cases and error handling for collection access."""
+
+    def test_large_index_access(self) -> None:
+        """Test accessing elements with large indices."""
+        source = """
+Set `data` to:
+- _"a"_
+- _"b"_
+- _"c"_
+
+Set `value` to item _877_ of `data`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        # Should parse (runtime will handle out-of-bounds)
+        assert len(program.statements) == 2
+
+    def test_last_item_access(self) -> None:
+        """Test accessing the last item of collections."""
+        source = """
+Set `nums` to:
+- _1_.
+- _2_.
+- _3_.
+- _4_.
+- _5_.
+
+Set `last_num` to the last item of `nums`.
+"""
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(program.statements) == 2
+        # Don't check for errors since we're just testing syntax
+
+    def test_empty_collection_operations(self) -> None:
+        """Test operations on empty collections."""
+        source = """
+Define `empty_list` as an unordered list.
+Define `empty_dict` as a named list.
+Set `val` to the first item of `empty_list`.
+Set `keys` to the names of `empty_dict`.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        # Should parse even if runtime would fail
+        assert len(program.statements) == 4

machine_dialect/type_checking/__init__.py

@@ -0,0 +1,21 @@
+"""Type system for Machine Dialect™ compile-time type checking."""
+
+from .type_system import (
+    TYPE_DISPLAY_NAMES,
+    MDType,
+    TypeSpec,
+    check_type_compatibility,
+    get_type_from_name,
+    get_type_from_value,
+    is_assignable_to,
+)
+
+__all__ = [
+    "TYPE_DISPLAY_NAMES",
+    "MDType",
+    "TypeSpec",
+    "check_type_compatibility",
+    "get_type_from_name",
+    "get_type_from_value",
+    "is_assignable_to",
+]

machine_dialect/type_checking/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Machine Dialect™ type system."""

machine_dialect/type_checking/tests/test_type_system.py

@@ -0,0 +1,230 @@
+"""Tests for the Machine Dialect™ compile-time type system."""
+
+from machine_dialect.ast import (
+    EmptyLiteral,
+    FloatLiteral,
+    StringLiteral,
+    URLLiteral,
+    WholeNumberLiteral,
+    YesNoLiteral,
+)
+from machine_dialect.lexer import Token, TokenType
+from machine_dialect.type_checking import (
+    MDType,
+    TypeSpec,
+    check_type_compatibility,
+    get_type_from_name,
+    get_type_from_value,
+    is_assignable_to,
+)
+
+
+class TestMDType:
+    """Test the MDType enumeration and type name mappings."""
+
+    def test_type_from_name(self) -> None:
+        """Test converting type names to MDType enum."""
+        assert get_type_from_name("Text") == MDType.TEXT
+        assert get_type_from_name("Whole Number") == MDType.WHOLE_NUMBER
+        assert get_type_from_name("Float") == MDType.FLOAT
+        assert get_type_from_name("Number") == MDType.NUMBER
+        assert get_type_from_name("Yes/No") == MDType.YES_NO
+        assert get_type_from_name("URL") == MDType.URL
+        assert get_type_from_name("Empty") == MDType.EMPTY
+        assert get_type_from_name("Any") == MDType.ANY
+
+    def test_type_from_invalid_name(self) -> None:
+        """Test that invalid type names return None."""
+        assert get_type_from_name("Invalid") is None
+        assert get_type_from_name("") is None
+        assert get_type_from_name("text") is None  # Case sensitive
+
+
+class TestTypeSpec:
+    """Test TypeSpec class for union type handling."""
+
+    def test_single_type_spec(self) -> None:
+        """Test TypeSpec with a single type."""
+        spec = TypeSpec(["Whole Number"])
+        assert spec.allows_type(MDType.WHOLE_NUMBER)
+        assert not spec.allows_type(MDType.TEXT)
+        assert str(spec) == "Whole Number"
+
+    def test_union_type_spec(self) -> None:
+        """Test TypeSpec with union types."""
+        spec = TypeSpec(["Whole Number", "Text", "Yes/No"])
+        assert spec.allows_type(MDType.WHOLE_NUMBER)
+        assert spec.allows_type(MDType.TEXT)
+        assert spec.allows_type(MDType.YES_NO)
+        assert not spec.allows_type(MDType.FLOAT)
+        assert str(spec) == "Whole Number or Text or Yes/No"
+
+    def test_number_type_allows_subtypes(self) -> None:
+        """Test that Number type allows Whole Number and Float."""
+        spec = TypeSpec(["Number"])
+        assert spec.allows_type(MDType.NUMBER)
+        assert spec.allows_type(MDType.WHOLE_NUMBER)
+        assert spec.allows_type(MDType.FLOAT)
+        assert not spec.allows_type(MDType.TEXT)
+
+    def test_any_type_allows_everything(self) -> None:
+        """Test that Any type allows all types."""
+        spec = TypeSpec(["Any"])
+        assert spec.allows_type(MDType.TEXT)
+        assert spec.allows_type(MDType.WHOLE_NUMBER)
+        assert spec.allows_type(MDType.FLOAT)
+        assert spec.allows_type(MDType.YES_NO)
+        assert spec.allows_type(MDType.EMPTY)
+
+
+class TestGetTypeFromValue:
+    """Test determining types from AST literal values."""
+
+    def test_whole_number_literal(self) -> None:
+        """Test type detection for WholeNumberLiteral."""
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", 1, 1)
+        literal = WholeNumberLiteral(token, 42)
+        assert get_type_from_value(literal) == MDType.WHOLE_NUMBER
+
+    def test_float_literal(self) -> None:
+        """Test type detection for FloatLiteral."""
+        token = Token(TokenType.LIT_FLOAT, "3.14", 1, 1)
+        literal = FloatLiteral(token, 3.14)
+        assert get_type_from_value(literal) == MDType.FLOAT
+
+    def test_string_literal(self) -> None:
+        """Test type detection for StringLiteral."""
+        token = Token(TokenType.LIT_TEXT, "hello", 1, 1)
+        literal = StringLiteral(token, "hello")
+        assert get_type_from_value(literal) == MDType.TEXT
+
+    def test_url_literal(self) -> None:
+        """Test type detection for URLLiteral."""
+        token = Token(TokenType.LIT_URL, "https://example.com", 1, 1)
+        literal = URLLiteral(token, "https://example.com")
+        assert get_type_from_value(literal) == MDType.URL
+
+    def test_yes_no_literal(self) -> None:
+        """Test type detection for YesNoLiteral."""
+        token = Token(TokenType.LIT_YES, "yes", 1, 1)
+        literal = YesNoLiteral(token, True)
+        assert get_type_from_value(literal) == MDType.YES_NO
+
+    def test_empty_literal(self) -> None:
+        """Test type detection for EmptyLiteral."""
+        token = Token(TokenType.KW_EMPTY, "empty", 1, 1)
+        literal = EmptyLiteral(token)
+        assert get_type_from_value(literal) == MDType.EMPTY
+
+    def test_string_that_looks_like_url(self) -> None:
+        """Test that strings starting with http are detected as URLs."""
+        token = Token(TokenType.LIT_TEXT, "https://example.com", 1, 1)
+        literal = StringLiteral(token, "https://example.com")
+        assert get_type_from_value(literal) == MDType.URL
+
+    def test_python_types(self) -> None:
+        """Test type detection for raw Python values."""
+        assert get_type_from_value(42) == MDType.WHOLE_NUMBER
+        assert get_type_from_value(3.14) == MDType.FLOAT
+        assert get_type_from_value("hello") == MDType.TEXT
+        assert get_type_from_value(True) == MDType.YES_NO
+        assert get_type_from_value(None) == MDType.EMPTY
+
+
+class TestTypeAssignability:
+    """Test type assignability rules."""
+
+    def test_exact_match_allowed(self) -> None:
+        """Test that exact type matches are allowed."""
+        assert is_assignable_to(MDType.WHOLE_NUMBER, MDType.WHOLE_NUMBER)
+        assert is_assignable_to(MDType.TEXT, MDType.TEXT)
+        assert is_assignable_to(MDType.FLOAT, MDType.FLOAT)
+
+    def test_any_accepts_all(self) -> None:
+        """Test that Any type accepts all values."""
+        assert is_assignable_to(MDType.TEXT, MDType.ANY)
+        assert is_assignable_to(MDType.WHOLE_NUMBER, MDType.ANY)
+        assert is_assignable_to(MDType.EMPTY, MDType.ANY)
+
+    def test_number_accepts_numeric(self) -> None:
+        """Test that Number accepts Whole Number and Float."""
+        assert is_assignable_to(MDType.WHOLE_NUMBER, MDType.NUMBER)
+        assert is_assignable_to(MDType.FLOAT, MDType.NUMBER)
+        assert not is_assignable_to(MDType.TEXT, MDType.NUMBER)
+
+    def test_empty_assignable_to_any_type(self) -> None:
+        """Test that Empty can be assigned to any type."""
+        assert is_assignable_to(MDType.EMPTY, MDType.TEXT)
+        assert is_assignable_to(MDType.EMPTY, MDType.WHOLE_NUMBER)
+        assert is_assignable_to(MDType.EMPTY, MDType.YES_NO)
+
+    def test_no_implicit_conversions(self) -> None:
+        """Test that no implicit conversions are allowed (per spec)."""
+        assert not is_assignable_to(MDType.WHOLE_NUMBER, MDType.TEXT)
+        assert not is_assignable_to(MDType.TEXT, MDType.WHOLE_NUMBER)
+        assert not is_assignable_to(MDType.WHOLE_NUMBER, MDType.YES_NO)
+        assert not is_assignable_to(MDType.FLOAT, MDType.WHOLE_NUMBER)
+
+
+class TestTypeCompatibility:
+    """Test type compatibility checking with TypeSpec."""
+
+    def test_compatible_single_type(self) -> None:
+        """Test compatibility with single type spec."""
+        spec = TypeSpec(["Whole Number"])
+        is_compatible, error = check_type_compatibility(MDType.WHOLE_NUMBER, spec)
+        assert is_compatible
+        assert error is None
+
+    def test_incompatible_single_type(self) -> None:
+        """Test incompatibility with single type spec."""
+        spec = TypeSpec(["Whole Number"])
+        is_compatible, error = check_type_compatibility(MDType.TEXT, spec)
+        assert not is_compatible
+        assert error == "Cannot assign Text value to variable of type Whole Number"
+
+    def test_compatible_union_type(self) -> None:
+        """Test compatibility with union type spec."""
+        spec = TypeSpec(["Whole Number", "Text"])
+
+        # Both types should be compatible
+        is_compatible, error = check_type_compatibility(MDType.WHOLE_NUMBER, spec)
+        assert is_compatible
+        assert error is None
+
+        is_compatible, error = check_type_compatibility(MDType.TEXT, spec)
+        assert is_compatible
+        assert error is None
+
+    def test_incompatible_union_type(self) -> None:
+        """Test incompatibility with union type spec."""
+        spec = TypeSpec(["Whole Number", "Text"])
+        is_compatible, error = check_type_compatibility(MDType.YES_NO, spec)
+        assert not is_compatible
+        assert error == "Cannot assign Yes/No value to variable of type Whole Number or Text"
+
+    def test_number_type_compatibility(self) -> None:
+        """Test Number type accepts both integers and floats."""
+        spec = TypeSpec(["Number"])
+
+        # Whole Number should be compatible
+        is_compatible, error = check_type_compatibility(MDType.WHOLE_NUMBER, spec)
+        assert is_compatible
+        assert error is None
+
+        # Float should be compatible
+        is_compatible, error = check_type_compatibility(MDType.FLOAT, spec)
+        assert is_compatible
+        assert error is None
+
+        # Text should not be compatible
+        is_compatible, error = check_type_compatibility(MDType.TEXT, spec)
+        assert not is_compatible
+
+    def test_empty_compatible_with_all(self) -> None:
+        """Test that Empty is compatible with all types."""
+        for type_name in ["Text", "Whole Number", "Float", "Yes/No", "URL"]:
+            spec = TypeSpec([type_name])
+            is_compatible, error = check_type_compatibility(MDType.EMPTY, spec)
+            assert is_compatible
+            assert error is None