machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/semantic/error_messages.py

@@ -0,0 +1,189 @@
+"""Error message generation for semantic analysis.
+
+This module provides helpful error messages with context and suggestions
+for semantic analysis errors.
+"""
+
+from difflib import SequenceMatcher
+
+
+class ErrorMessageGenerator:
+    """Generates helpful error messages with context and suggestions."""
+
+    @staticmethod
+    def undefined_variable(var_name: str, line: int, position: int, similar_vars: list[str] | None = None) -> str:
+        """Generate error message for undefined variable.
+
+        Args:
+            var_name: Variable name that's undefined
+            line: Line number
+            position: Column position
+            similar_vars: List of similar variable names
+
+        Returns:
+            Formatted error message
+        """
+        base_msg = f"Variable '{var_name}' is not defined"
+
+        # Add line/position info
+        location = f" at line {line}, column {position}"
+
+        # Add suggestions if similar variables exist
+        suggestion = ""
+        if similar_vars:
+            if len(similar_vars) == 1:
+                suggestion = f"\nDid you mean '{similar_vars[0]}'?"
+            else:
+                vars_list = "', '".join(similar_vars[:3])
+                suggestion = f"\nDid you mean one of: '{vars_list}'?"
+
+        # Add hint for defining variable
+        hint = f"\nHint: Add 'Define `{var_name}` as Type.' before using it"
+
+        return base_msg + location + suggestion + hint
+
+    @staticmethod
+    def type_mismatch(
+        var_name: str,
+        expected_types: list[str],
+        actual_type: str,
+        line: int,
+        position: int,
+        value_repr: str | None = None,
+    ) -> str:
+        """Generate error message for type mismatch.
+
+        Args:
+            var_name: Variable name
+            expected_types: List of expected type names
+            actual_type: Actual type found
+            line: Line number
+            position: Column position
+            value_repr: String representation of the value
+
+        Returns:
+            Formatted error message
+        """
+        location = f"Error at line {line}, column {position}:"
+
+        if len(expected_types) == 1:
+            expected_str = expected_types[0]
+            main_msg = f"Cannot set {expected_str} variable '{var_name}' to {actual_type} value"
+        else:
+            expected_str = " or ".join(expected_types)
+            main_msg = f"Cannot set '{var_name}' to {actual_type} value"
+
+        if value_repr:
+            main_msg += f" {value_repr}"
+
+        type_info = f"\nExpected: {expected_str}\nActual: {actual_type}"
+
+        # Add conversion hint if applicable
+        hint = ""
+        if actual_type == "Whole Number" and "Float" in expected_types:
+            try:
+                # Try to convert value_repr to int first to ensure proper formatting
+                if value_repr and value_repr.isdigit():
+                    hint = f"\nHint: Use _{value_repr}.0_ to make it a Float"
+                else:
+                    hint = f"\nHint: Use _{value_repr or 'value'}.0_ to make it a Float"
+            except Exception:
+                hint = "\nHint: Use _value.0_ to make it a Float"
+        elif actual_type == "Float" and "Whole Number" in expected_types:
+            hint = "\nHint: Float values cannot be assigned to Whole Number variables"
+
+        return f"{location}\n{main_msg}{type_info}{hint}"
+
+    @staticmethod
+    def redefinition(
+        var_name: str, new_line: int, new_position: int, original_line: int, original_position: int
+    ) -> str:
+        """Generate error message for variable redefinition.
+
+        Args:
+            var_name: Variable name
+            new_line: Line of redefinition attempt
+            new_position: Column of redefinition attempt
+            original_line: Line of original definition
+            original_position: Column of original definition
+
+        Returns:
+            Formatted error message
+        """
+        location = f"Error at line {new_line}, column {new_position}:"
+        main_msg = f"Variable '{var_name}' is already defined"
+        original = f"\nOriginal definition at line {original_line}, column {original_position}"
+        hint = "\nHint: Variables cannot be redefined. Use 'Set' to change the value"
+
+        return f"{location}\n{main_msg}{original}{hint}"
+
+    @staticmethod
+    def uninitialized_use(var_name: str, line: int, position: int, definition_line: int) -> str:
+        """Generate error message for using uninitialized variable.
+
+        Args:
+            var_name: Variable name
+            line: Line where used
+            position: Column where used
+            definition_line: Line where defined
+
+        Returns:
+            Formatted error message
+        """
+        location = f"Error at line {line}, column {position}:"
+        main_msg = f"Variable '{var_name}' is used before being initialized"
+        definition = f"\nVariable was defined at line {definition_line}"
+        hint = f"\nHint: Add 'Set `{var_name}` to value.' before using it"
+
+        return f"{location}\n{main_msg}{definition}{hint}"
+
+    @staticmethod
+    def invalid_type(type_name: str, line: int, position: int, valid_types: list[str]) -> str:
+        """Generate error message for invalid type name.
+
+        Args:
+            type_name: Invalid type name
+            line: Line number
+            position: Column position
+            valid_types: List of valid type names
+
+        Returns:
+            Formatted error message
+        """
+        location = f"Error at line {line}, column {position}:"
+        main_msg = f"Unknown type '{type_name}'"
+
+        # Find similar valid types
+        similar = ErrorMessageGenerator._find_similar(type_name, valid_types)
+        suggestion = ""
+        if similar:
+            if len(similar) == 1:
+                suggestion = f"\nDid you mean '{similar[0]}'?"
+            else:
+                suggestion = f"\nDid you mean one of: {', '.join(similar[:3])}"
+
+        valid_list = "\nValid types: " + ", ".join(sorted(valid_types))
+
+        return f"{location}\n{main_msg}{suggestion}{valid_list}"
+
+    @staticmethod
+    def _find_similar(name: str, candidates: list[str], threshold: float = 0.6) -> list[str]:
+        """Find similar names using edit distance.
+
+        Args:
+            name: Name to match
+            candidates: List of candidate names
+            threshold: Similarity threshold (0-1)
+
+        Returns:
+            List of similar names
+        """
+        similarities = []
+        for candidate in candidates:
+            ratio = SequenceMatcher(None, name.lower(), candidate.lower()).ratio()
+            if ratio >= threshold:
+                similarities.append((candidate, ratio))
+
+        # Sort by similarity and return names only
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [name for name, _ in similarities[:5]]

machine_dialect/semantic/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for semantic analysis components."""

machine_dialect/semantic/tests/test_analyzer.py

@@ -0,0 +1,364 @@
+"""Tests for semantic analyzer functionality.
+
+This module tests the semantic analysis capabilities including type checking,
+variable usage validation, and error detection.
+"""
+
+from machine_dialect.errors import MDNameError, MDTypeError
+from machine_dialect.parser import Parser
+from machine_dialect.semantic.analyzer import SemanticAnalyzer
+
+
+class TestSemanticAnalyzer:
+    """Test semantic analysis functionality."""
+
+    def test_undefined_variable_error(self) -> None:
+        """Test error for using undefined variable."""
+        source = """
+        Set `x` to _5_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDNameError)
+        assert "not defined" in str(errors[0])
+        assert "Define" in str(errors[0])  # Should suggest Define
+
+    def test_type_mismatch_error(self) -> None:
+        """Test error for type mismatch."""
+        source = """
+        Define `age` as Whole Number.
+        Set `age` to _"twenty"_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDTypeError)
+        assert "Whole Number" in str(errors[0])
+        assert "Text" in str(errors[0])
+
+    def test_redefinition_error(self) -> None:
+        """Test error for variable redefinition."""
+        source = """
+        Define `x` as Whole Number.
+        Define `x` as Text.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDNameError)
+        assert "already defined" in str(errors[0])
+
+    def test_valid_union_type_assignment(self) -> None:
+        """Test valid assignment to union type."""
+        source = """
+        Define `value` as Whole Number or Text.
+        Set `value` to _42_.
+        Set `value` to _"hello"_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_invalid_union_type_assignment(self) -> None:
+        """Test invalid assignment to union type."""
+        source = """
+        Define `value` as Whole Number or Text.
+        Set `value` to _yes_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDTypeError)
+        assert "Yes/No" in str(errors[0])
+        assert "Whole Number" in str(errors[0]) or "Text" in str(errors[0])
+
+    def test_default_value_type_check(self) -> None:
+        """Test type checking for default values."""
+        source = """
+        Define `count` as Whole Number (default: _"zero"_).
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDTypeError)
+        assert "Default value" in str(errors[0])
+
+    def test_uninitialized_variable_use(self) -> None:
+        """Test error for using uninitialized variable."""
+        source = """
+        Define `x` as Whole Number.
+        Define `y` as Whole Number.
+        Set `y` to `x`.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 1
+        assert "before being initialized" in str(errors[0])
+
+    def test_number_type_accepts_int_and_float(self) -> None:
+        """Test that Number type accepts both Whole Number and Float."""
+        source = """
+        Define `value` as Number.
+        Set `value` to _42_.
+        Set `value` to _3.14_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_valid_default_value(self) -> None:
+        """Test valid default value with matching type."""
+        source = """
+        Define `count` as Whole Number (default: _0_).
+        Define `name` as Text (default: _"John"_).
+        Define `active` as Yes/No (default: _yes_).
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_empty_type_compatibility(self) -> None:
+        """Test that Empty type works with nullable types."""
+        source = """
+        Define `optional` as Text or Empty.
+        Set `optional` to _"text"_.
+        Set `optional` to empty.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_invalid_type_name(self) -> None:
+        """Test error for invalid type name."""
+        source = """
+        Define `x` as String.
+        """
+        parser = Parser()
+        parser.parse(source, check_semantics=False)
+
+        # Parser already catches invalid type names and creates an ErrorStatement
+        # So semantic analyzer won't see it
+        assert len(parser.errors) == 1
+        assert "String" in str(parser.errors[0])
+
+    def test_expression_type_inference(self) -> None:
+        """Test type inference for expressions."""
+        source = """
+        Define `sum` as Whole Number.
+        Define `a` as Whole Number.
+        Define `b` as Whole Number.
+        Set `a` to _5_.
+        Set `b` to _10_.
+        Set `sum` to `a` + `b`.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        # Should be valid - no errors
+        assert len(errors) == 0
+
+    def test_comparison_returns_boolean(self) -> None:
+        """Test that comparison operators return Yes/No type."""
+        source = """
+        Define `result` as Yes/No.
+        Define `x` as Whole Number.
+        Set `x` to _5_.
+        Set `result` to `x` > _3_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_division_returns_float(self) -> None:
+        """Test that division always returns Float type."""
+        source = """
+        Define `result` as Float.
+        Define `x` as Whole Number.
+        Define `y` as Whole Number.
+        Set `x` to _10_.
+        Set `y` to _3_.
+        Set `result` to `x` / `y`.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_bitwise_operators_type_inference(self) -> None:
+        """Test that bitwise operators return Whole Number type."""
+        source = """
+        Define `a` as Whole Number.
+        Define `b` as Whole Number.
+        Define `result` as Whole Number.
+        Set `a` to _5_.
+        Set `b` to _3_.
+        """
+        # Note: We can't fully test bitwise operators without parser support
+        # but the type inference is ready when the parser supports them
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        assert len(errors) == 0
+
+    def test_arguments_expression_type(self) -> None:
+        """Test that Arguments expression returns None for type."""
+        from machine_dialect.ast.expressions import Arguments
+        from machine_dialect.lexer import Token, TokenType
+
+        analyzer = SemanticAnalyzer()
+
+        # Create an Arguments expression
+        args = Arguments(Token(TokenType.DELIM_LPAREN, "(", 1, 1))
+
+        # Type inference should return None for Arguments
+        type_info = analyzer._infer_expression_type(args)
+        assert type_info is None
+
+    def test_function_return_type_inference(self) -> None:
+        """Test that function calls can infer return type from symbol table."""
+        # This would require parsing function definitions and calls
+        # For now, we just test that the infrastructure is in place
+        from machine_dialect.ast import Identifier
+        from machine_dialect.ast.call_expression import CallExpression
+        from machine_dialect.lexer import Token, TokenType
+
+        analyzer = SemanticAnalyzer()
+
+        # Manually add a function to the symbol table with return type
+        analyzer.symbol_table.define("my_func", ["Function"], 1, 1)
+        func_info = analyzer.symbol_table.lookup("my_func")
+        if func_info:
+            func_info.return_type = "Text"  # Set return type
+
+        # Create a call expression
+        func_name = Identifier(Token(TokenType.MISC_IDENT, "my_func", 1, 1), "my_func")
+        call_expr = CallExpression(Token(TokenType.KW_USE, "use", 1, 1), func_name, None)
+
+        # Type inference should return Text
+        type_info = analyzer._infer_expression_type(call_expr)
+        assert type_info is not None
+        assert type_info.type_name == "Text"
+
+    def test_function_definition_with_return_type(self) -> None:
+        """Test that function definitions store return type information."""
+        from machine_dialect.ast import Identifier
+        from machine_dialect.ast.program import Program
+        from machine_dialect.ast.statements import (
+            ActionStatement,
+            BlockStatement,
+        )
+        from machine_dialect.lexer import Token, TokenType
+
+        # Create an AST for: Action "add_one" with input `x` as Whole Number, output `result` as Whole Number
+        name = Identifier(Token(TokenType.MISC_IDENT, "add_one", 1, 8), "add_one")
+        action = ActionStatement(Token(TokenType.KW_ACTION, "action", 1, 1), name)
+
+        # Create input parameter
+        from machine_dialect.ast.statements import Output, Parameter
+
+        param_name = Identifier(Token(TokenType.MISC_IDENT, "x", 1, 20), "x")
+        input_param = Parameter(Token(TokenType.MISC_IDENT, "x", 1, 20), param_name, type_name="Whole Number")
+        action.inputs = [input_param]
+
+        # Create output parameter
+        output_name = Identifier(Token(TokenType.MISC_IDENT, "result", 1, 40), "result")
+        output_param = Output(Token(TokenType.MISC_IDENT, "result", 1, 40), output_name, type_name="Whole Number")
+        action.outputs = [output_param]
+
+        # Create body (empty for simplicity)
+        action.body = BlockStatement(Token(TokenType.DELIM_LBRACE, "{", 2, 1))
+        action.body.statements = []
+
+        # Create program
+        program = Program([action])
+
+        # Analyze
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        # Should have no errors
+        assert len(errors) == 0
+
+        # Function should be defined with return type
+        func_info = analyzer.symbol_table.lookup("add_one")
+        assert func_info is not None
+        assert func_info.type_spec == ["Function"]
+        assert func_info.return_type == "Whole Number"
+
+    def test_scoped_definitions(self) -> None:
+        """Test variable scoping - variables defined in inner scope not accessible in outer scope."""
+        source = """
+        Define `x` as Whole Number.
+        Set `x` to _5_.
+
+        If _yes_ then:
+        > Define `y` as Text.
+        > Set `y` to _"hello"_.
+
+        Set `y` to _"world"_.
+        """
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        analyzer = SemanticAnalyzer()
+        _, errors = analyzer.analyze(program)
+
+        # Should have one error for accessing 'y' outside its scope
+        assert len(errors) == 1
+        assert isinstance(errors[0], MDNameError)
+        assert "not defined" in str(errors[0])
+        assert "y" in str(errors[0])

machine_dialect/semantic/tests/test_error_messages.py

@@ -0,0 +1,104 @@
+"""Tests for error message generation.
+
+This module tests the generation of helpful error messages with suggestions.
+"""
+
+from machine_dialect.semantic.error_messages import ErrorMessageGenerator
+
+
+class TestErrorMessages:
+    """Test error message generation."""
+
+    def test_undefined_variable_message(self) -> None:
+        """Test undefined variable error message."""
+        msg = ErrorMessageGenerator.undefined_variable("counter", 5, 10, similar_vars=["count", "counter1"])
+
+        assert "Variable 'counter' is not defined" in msg
+        assert "line 5, column 10" in msg
+        assert "Did you mean" in msg
+        assert "count" in msg
+        assert "Define `counter` as Type" in msg
+
+    def test_type_mismatch_message(self) -> None:
+        """Test type mismatch error message."""
+        msg = ErrorMessageGenerator.type_mismatch("age", ["Whole Number"], "Text", 8, 5, '"twenty"')
+
+        assert "Cannot set Whole Number variable 'age'" in msg
+        assert "Text value" in msg
+        assert "Expected: Whole Number" in msg
+        assert "Actual: Text" in msg
+
+    def test_type_mismatch_union_message(self) -> None:
+        """Test type mismatch error message for union types."""
+        msg = ErrorMessageGenerator.type_mismatch("id", ["Whole Number", "Text"], "Yes/No", 10, 3, "yes")
+
+        assert "Cannot set 'id'" in msg
+        assert "Yes/No value" in msg
+        assert "Expected: Whole Number or Text" in msg
+        assert "Actual: Yes/No" in msg
+
+    def test_redefinition_message(self) -> None:
+        """Test redefinition error message."""
+        msg = ErrorMessageGenerator.redefinition("x", 10, 1, 5, 1)
+
+        assert "Variable 'x' is already defined" in msg
+        assert "line 10, column 1" in msg
+        assert "Original definition at line 5" in msg
+        assert "Use 'Set' to change the value" in msg
+
+    def test_uninitialized_use_message(self) -> None:
+        """Test uninitialized use error message."""
+        msg = ErrorMessageGenerator.uninitialized_use("data", 15, 8, 3)
+
+        assert "Variable 'data' is used before being initialized" in msg
+        assert "line 15, column 8" in msg
+        assert "defined at line 3" in msg
+        assert "Set `data` to value" in msg
+
+    def test_invalid_type_message(self) -> None:
+        """Test invalid type error message."""
+        msg = ErrorMessageGenerator.invalid_type("Str", 5, 15, ["Text", "Whole Number", "Float", "Yes/No"])
+
+        assert "Unknown type 'Str'" in msg
+        assert "Valid types:" in msg
+        # The similarity detection may not suggest Text for "Str" with default threshold
+
+    def test_undefined_without_suggestions(self) -> None:
+        """Test undefined variable message without suggestions."""
+        msg = ErrorMessageGenerator.undefined_variable("xyz", 3, 7, similar_vars=None)
+
+        assert "Variable 'xyz' is not defined" in msg
+        assert "line 3, column 7" in msg
+        assert "Did you mean" not in msg
+        assert "Define `xyz` as Type" in msg
+
+    def test_type_conversion_hints(self) -> None:
+        """Test type mismatch messages include conversion hints."""
+        # Whole Number to Float hint
+        msg = ErrorMessageGenerator.type_mismatch("price", ["Float"], "Whole Number", 5, 10, "42")
+        assert "Use _42.0_ to make it a Float" in msg
+
+        # Float to Whole Number hint
+        msg = ErrorMessageGenerator.type_mismatch("count", ["Whole Number"], "Float", 6, 10, "3.14")
+        assert "Float values cannot be assigned to Whole Number variables" in msg
+
+    def test_similar_name_detection(self) -> None:
+        """Test similar name detection algorithm."""
+        similar = ErrorMessageGenerator._find_similar(
+            "count", ["counter", "amount", "count1", "total", "cnt"], threshold=0.6
+        )
+
+        # Should find similar names
+        assert "count1" in similar
+        assert "counter" in similar
+
+        # Should be ordered by similarity
+        assert similar.index("count1") < similar.index("cnt")
+
+    def test_invalid_type_with_multiple_suggestions(self) -> None:
+        """Test invalid type message with multiple suggestions."""
+        msg = ErrorMessageGenerator.invalid_type("Num", 7, 20, ["Number", "Whole Number", "Float", "Text", "Yes/No"])
+
+        assert "Unknown type 'Num'" in msg
+        assert "Did you mean one of:" in msg or "Did you mean 'Number'?" in msg
+        assert "Valid types:" in msg

machine_dialect/tests/edge_cases/__init__.py

@@ -0,0 +1,10 @@
+"""Edge case tests for Machine Dialect™ collection operations.
+
+This package contains comprehensive edge case testing for:
+- Empty collection operations
+- Boundary access conditions
+- Invalid operations
+- Type mixing scenarios
+- Nested structures
+- Named list (dictionary) edge cases
+"""