machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/linter/tests/mdrules/test_md101_statement_termination.py

@@ -0,0 +1,181 @@
+"""Tests specifically for MD101: Statement Termination rule."""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement, ReturnStatement, SetStatement
+from machine_dialect.lexer import Token, TokenType
+from machine_dialect.linter import Linter
+from machine_dialect.linter.rules.base import Context
+from machine_dialect.linter.rules.statement_termination import StatementTerminationRule
+from machine_dialect.linter.violations import ViolationSeverity
+
+
+class TestMD101StatementTermination:
+    """Test MD101: Statement Termination rule."""
+
+    def test_rule_metadata(self) -> None:
+        """Test that MD101 has correct metadata."""
+        rule = StatementTerminationRule()
+        assert rule.rule_id == "MD101"
+        assert "period" in rule.description.lower()
+        assert "statement" in rule.description.lower()
+
+    @pytest.mark.parametrize(
+        ("source", "expected_violations"),
+        [
+            # Valid cases - no violations
+            ("42.", 0),
+            ("True.", 0),
+            ("not False.", 0),
+            ("-123.", 0),
+            ("Set `x` to 42.", 0),
+            ("give back 42.", 0),
+            ("gives back True.", 0),
+            # Valid cases - no period needed at EOF
+            ("42", 0),
+            ("True", 0),
+            ("not False", 0),
+            ("-123", 0),
+            # Multiple statements
+            ("42. True.", 0),
+            # Note: These now generate parse errors, not MD101 violations
+            # because periods are mandatory (except at EOF) at the parser level
+            ("42\nTrue.", 0),  # Parse error, not MD101
+            ("42.\nTrue", 0),  # Valid: second line at EOF
+            ("42\nTrue", 0),  # Parse error, not MD101
+        ],
+    )
+    def test_full_integration(self, source: str, expected_violations: int) -> None:
+        """Test MD101 through the full linter integration."""
+        linter = Linter()
+        violations = linter.lint(source)
+
+        # Filter for MD101 violations only
+        md101_violations = [v for v in violations if v.rule_id == "MD101"]
+        assert len(md101_violations) == expected_violations
+
+        # All MD101 violations should be STYLE severity
+        for violation in md101_violations:
+            assert violation.severity == ViolationSeverity.STYLE
+            assert "period" in violation.message.lower()
+
+    def test_statements_with_complex_content(self) -> None:
+        """Test MD101 with complex statement content."""
+        rule = StatementTerminationRule()
+
+        # Test with expression that has operators
+        token = Token(TokenType.OP_MINUS, "-", line=1, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+
+        # Source: "-42 + 5" (no period, at EOF - valid)
+        context = Context("test.md", "-42 + 5")
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+        # Source: "-42 + 5." (with period)
+        context = Context("test.md", "-42 + 5.")
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_set_statements(self) -> None:
+        """Test MD101 specifically with Set statements."""
+        rule = StatementTerminationRule()
+
+        # Create a Set statement node
+        token = Token(TokenType.KW_SET, "Set", line=1, position=0)
+        node = SetStatement(token=token)
+
+        # Test without period (at EOF - valid)
+        context = Context("test.md", "Set `x` to 42")
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+        # Test with period
+        context = Context("test.md", "Set `x` to 42.")
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_return_statements(self) -> None:
+        """Test MD101 specifically with Return statements."""
+        rule = StatementTerminationRule()
+
+        # Create a Return statement node
+        token = Token(TokenType.KW_RETURN, "give back", line=1, position=0)
+        node = ReturnStatement(token=token)
+
+        # Test without period (at EOF - valid)
+        context = Context("test.md", "give back 42")
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+        # Test with period
+        context = Context("test.md", "give back 42.")
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_multiline_source(self) -> None:
+        """Test MD101 with multiline source code."""
+        rule = StatementTerminationRule()
+
+        source = """42.
+True
+-5.
+not False"""
+
+        # Test line 2 (True without period)
+        token = Token(TokenType.LIT_YES, "True", line=2, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+        context = Context("test.md", source)
+        violations = rule.check(node, context)
+        assert len(violations) == 1
+        assert violations[0].line == 2
+
+        # Test line 4 (not False without period, at EOF - valid)
+        token = Token(TokenType.KW_NEGATION, "not", line=4, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+    def test_fix_suggestion(self) -> None:
+        """Test that MD101 provides fix suggestions."""
+        rule = StatementTerminationRule()
+
+        # Test with a statement not at EOF
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+        context = Context("test.md", "42\nTrue.")  # Not at EOF
+
+        violations = rule.check(node, context)
+        assert len(violations) == 1
+        assert violations[0].fix_suggestion is not None
+        assert "period" in violations[0].fix_suggestion.lower()
+
+    def test_edge_cases(self) -> None:
+        """Test MD101 edge cases."""
+        rule = StatementTerminationRule()
+
+        # Empty line
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+        context = Context("test.md", "")
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No crash on empty source
+
+        # Line number out of bounds
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=10, position=0)
+        node = ExpressionStatement(token=token, expression=None)
+        context = Context("test.md", "42")
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No crash on invalid line number
+
+    def test_disabled_rule(self) -> None:
+        """Test that MD101 can be disabled."""
+        # Test with MD101 disabled
+        config = {"rules": {"MD101": False}}
+        linter = Linter(config)
+
+        source = "42"  # Missing period
+        violations = linter.lint(source)
+
+        # Should have no violations since MD101 is disabled
+        assert len(violations) == 0

machine_dialect/linter/tests/test_linter.py

@@ -0,0 +1,81 @@
+"""Tests for the main linter functionality."""
+
+from pathlib import Path
+
+from machine_dialect.linter import Linter, Violation, ViolationSeverity
+
+
+class TestLinter:
+    """Test the main Linter class."""
+
+    def test_linter_initialization(self) -> None:
+        """Test that linter initializes with default rules."""
+        linter = Linter()
+        assert len(linter.rules) > 0
+        assert any(rule.rule_id == "MD101" for rule in linter.rules)
+
+    def test_linter_with_config(self) -> None:
+        """Test linter initialization with configuration."""
+        config = {"rules": {"MD101": False}}
+        linter = Linter(config)
+
+        # MD101 should not be in the rules list
+        assert not any(rule.rule_id == "MD101" for rule in linter.rules)
+
+    def test_lint_parse_errors(self) -> None:
+        """Test that parse errors are reported as violations."""
+        source = "* 42"  # Invalid - no prefix parse function for *
+
+        linter = Linter()
+        violations = linter.lint(source)
+
+        assert len(violations) > 0
+        assert any(v.rule_id == "parse-error" for v in violations)
+        assert any(v.severity == ViolationSeverity.ERROR for v in violations)
+
+    def test_lint_stops_on_parse_errors(self) -> None:
+        """Test that linter doesn't run rules when there are parse errors."""
+        source = "* 42"  # Parse error
+
+        # Even with missing period, we should only get parse errors
+        linter = Linter()
+        violations = linter.lint(source)
+
+        # All violations should be parse errors
+        assert all(v.rule_id == "parse-error" for v in violations)
+
+    def test_lint_file(self, tmp_path: Path) -> None:
+        """Test linting a file from disk."""
+        # Create a temporary file
+        test_file = tmp_path / "test.md"
+        test_file.write_text("42.")
+
+        linter = Linter()
+        violations = linter.lint_file(str(test_file))
+
+        # Should have no violations
+        assert len(violations) == 0
+
+    def test_add_rule(self) -> None:
+        """Test adding custom rules to the linter."""
+        from machine_dialect.ast import ASTNode
+        from machine_dialect.linter.rules.base import Context, Rule
+
+        class CustomRule(Rule):
+            @property
+            def rule_id(self) -> str:
+                return "CUSTOM001"
+
+            @property
+            def description(self) -> str:
+                return "Custom test rule"
+
+            def check(self, node: ASTNode, context: Context) -> list[Violation]:
+                return []
+
+        linter = Linter()
+        initial_count = len(linter.rules)
+
+        linter.add_rule(CustomRule())
+        assert len(linter.rules) == initial_count + 1
+        assert any(rule.rule_id == "CUSTOM001" for rule in linter.rules)

machine_dialect/linter/tests/test_rules.py

@@ -0,0 +1,110 @@
+"""Tests for individual linting rules."""
+
+from machine_dialect.ast import ExpressionStatement, WholeNumberLiteral
+from machine_dialect.lexer import Token, TokenType
+from machine_dialect.linter.rules.base import Context
+from machine_dialect.linter.rules.statement_termination import StatementTerminationRule
+from machine_dialect.linter.violations import ViolationSeverity
+
+
+class TestStatementTerminationRule:
+    """Test the statement termination rule."""
+
+    def test_rule_properties(self) -> None:
+        """Test rule ID and description."""
+        rule = StatementTerminationRule()
+        assert rule.rule_id == "MD101"
+        assert "period" in rule.description.lower()
+
+    def test_valid_statement_with_period(self) -> None:
+        """Test that statements ending with periods pass."""
+        rule = StatementTerminationRule()
+
+        # Create a mock expression statement
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=1)
+        node = ExpressionStatement(token=token, expression=WholeNumberLiteral(token=token, value=42))
+
+        # Create context with source that has a period
+        context = Context("test.md", "42.")
+
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_missing_period(self) -> None:
+        """Test that statements without periods at EOF are valid."""
+        rule = StatementTerminationRule()
+
+        # Create a mock expression statement
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=1)
+        node = ExpressionStatement(token=token, expression=WholeNumberLiteral(token=token, value=42))
+
+        # Create context with source that lacks a period (at EOF - valid)
+        context = Context("test.md", "42")
+
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+        # Test with statement not at EOF (should have violation)
+        context = Context("test.md", "42\n100.")
+        violations = rule.check(node, context)
+        assert len(violations) == 1
+        assert violations[0].rule_id == "MD101"
+        assert violations[0].severity == ViolationSeverity.STYLE
+        assert violations[0].line == 1
+
+    def test_multiple_statements_on_line(self) -> None:
+        """Test handling of multiple statements on one line."""
+        rule = StatementTerminationRule()
+
+        # First statement in "42. 100"
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=1)
+        node = ExpressionStatement(token=token, expression=WholeNumberLiteral(token=token, value=42))
+
+        context = Context("test.md", "42. 100")
+
+        # First statement has a period, so no violation
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_statement_with_whitespace(self) -> None:
+        """Test statements with trailing whitespace."""
+        rule = StatementTerminationRule()
+
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=1)
+        node = ExpressionStatement(token=token, expression=WholeNumberLiteral(token=token, value=42))
+
+        # Test with trailing whitespace but no period (at EOF - valid)
+        context = Context("test.md", "42   ")
+
+        violations = rule.check(node, context)
+        assert len(violations) == 0  # No period needed at EOF
+
+    def test_non_statement_nodes(self) -> None:
+        """Test that non-statement nodes are ignored."""
+        rule = StatementTerminationRule()
+
+        # Test with a literal node (not a statement)
+        token = Token(TokenType.LIT_WHOLE_NUMBER, "42", line=1, position=1)
+        node = WholeNumberLiteral(token=token, value=42)
+
+        context = Context("test.md", "42")
+
+        # Should not check non-statement nodes
+        violations = rule.check(node, context)
+        assert len(violations) == 0
+
+    def test_rule_enabled_by_default(self) -> None:
+        """Test that rules are enabled by default."""
+        rule = StatementTerminationRule()
+        assert rule.is_enabled({})
+        assert rule.is_enabled({"rules": {}})
+
+    def test_rule_can_be_disabled(self) -> None:
+        """Test that rules can be disabled in config."""
+        rule = StatementTerminationRule()
+
+        config = {"rules": {"MD101": False}}
+        assert not rule.is_enabled(config)
+
+        config = {"rules": {"MD101": True}}
+        assert rule.is_enabled(config)

machine_dialect/linter/tests/test_violations.py

@@ -0,0 +1,71 @@
+"""Tests for the violations module."""
+
+from machine_dialect.linter.violations import Violation, ViolationSeverity
+
+
+class TestViolation:
+    """Test the Violation class."""
+
+    def test_violation_creation(self) -> None:
+        """Test creating a violation."""
+        violation = Violation(
+            rule_id="TEST001",
+            message="Test violation",
+            severity=ViolationSeverity.WARNING,
+            line=10,
+            column=5,
+        )
+
+        assert violation.rule_id == "TEST001"
+        assert violation.message == "Test violation"
+        assert violation.severity == ViolationSeverity.WARNING
+        assert violation.line == 10
+        assert violation.column == 5
+        assert violation.node is None
+        assert violation.fix_suggestion is None
+
+    def test_violation_with_optional_fields(self) -> None:
+        """Test violation with optional fields."""
+        violation = Violation(
+            rule_id="TEST002",
+            message="Test with suggestion",
+            severity=ViolationSeverity.STYLE,
+            line=1,
+            column=0,
+            fix_suggestion="Add a period",
+        )
+
+        assert violation.fix_suggestion == "Add a period"
+
+    def test_violation_string_representation(self) -> None:
+        """Test string representation of violations."""
+        violation = Violation(
+            rule_id="MD101",
+            message="Missing period",
+            severity=ViolationSeverity.STYLE,
+            line=5,
+            column=10,
+        )
+
+        str_repr = str(violation)
+        assert "5:10" in str_repr
+        assert "style" in str_repr
+        assert "MD101" in str_repr
+        assert "Missing period" in str_repr
+
+
+class TestViolationSeverity:
+    """Test the ViolationSeverity enum."""
+
+    def test_severity_values(self) -> None:
+        """Test that severity levels have expected values."""
+        assert ViolationSeverity.ERROR.value == "error"
+        assert ViolationSeverity.WARNING.value == "warning"
+        assert ViolationSeverity.INFO.value == "info"
+        assert ViolationSeverity.STYLE.value == "style"
+
+    def test_all_severities_defined(self) -> None:
+        """Test that all expected severities are defined."""
+        expected_severities = {"ERROR", "WARNING", "INFO", "STYLE"}
+        actual_severities = {s.name for s in ViolationSeverity}
+        assert expected_severities == actual_severities

machine_dialect/linter/violations.py

@@ -0,0 +1,51 @@
+"""Violation representation for the Machine Dialect™ linter.
+
+This module defines the Violation class used to represent linting issues
+found in Machine Dialect™ code.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+from machine_dialect.ast import ASTNode
+
+
+class ViolationSeverity(Enum):
+    """Severity levels for linting violations."""
+
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    STYLE = "style"
+
+
+@dataclass
+class Violation:
+    """Represents a linting violation found in Machine Dialect™ code.
+
+    Attributes:
+        rule_id: Unique identifier for the rule that was violated.
+        message: Human-readable description of the violation.
+        severity: The severity level of the violation.
+        line: Line number where the violation occurred.
+        column: Column number where the violation occurred.
+        node: The AST node associated with the violation (optional).
+        fix_suggestion: Suggested fix for the violation (optional).
+    """
+
+    rule_id: str
+    message: str
+    severity: ViolationSeverity
+    line: int
+    column: int
+    node: ASTNode | None = None
+    fix_suggestion: str | None = None
+
+    def __str__(self) -> str:
+        """Return a formatted string representation of the violation.
+
+        Returns:
+            A string in the format: "line:column severity rule_id: message"
+        """
+        location = f"{self.line}:{self.column}"
+        return f"{location} {self.severity.value} {self.rule_id}: {self.message}"

machine_dialect/mir/__init__.py

@@ -0,0 +1,69 @@
+"""Machine Dialect™ MIR (Medium-level Intermediate Representation).
+
+This module provides a Three-Address Code (TAC) based intermediate representation
+with Static Single Assignment (SSA) support for Machine Dialect™ compilation.
+
+The MIR sits between the HIR (desugared AST) and the final code generation
+targets (bytecode and LLVM IR).
+"""
+
+from .basic_block import CFG, BasicBlock
+from .hir_to_mir import HIRToMIRLowering, lower_to_mir
+from .mir_function import MIRFunction
+from .mir_instructions import (
+    BinaryOp,
+    Call,
+    ConditionalJump,
+    Copy,
+    Jump,
+    Label,
+    LoadConst,
+    LoadVar,
+    MIRInstruction,
+    Phi,
+    Return,
+    StoreVar,
+    UnaryOp,
+)
+from .mir_module import MIRModule
+from .mir_types import MIRType
+from .mir_values import Constant, FunctionRef, MIRValue, Temp, Variable
+from .optimization_config import OptimizationConfig
+from .optimization_pipeline import OptimizationLevel, OptimizationPipeline, PipelineBuilder
+from .optimize_mir import optimize_mir, optimize_mir_simple
+from .pass_manager import PassManager
+
+__all__ = [
+    "CFG",
+    "BasicBlock",
+    "BinaryOp",
+    "Call",
+    "ConditionalJump",
+    "Constant",
+    "Copy",
+    "FunctionRef",
+    "HIRToMIRLowering",
+    "Jump",
+    "Label",
+    "LoadConst",
+    "LoadVar",
+    "MIRFunction",
+    "MIRInstruction",
+    "MIRModule",
+    "MIRType",
+    "MIRValue",
+    "OptimizationConfig",
+    "OptimizationLevel",
+    "OptimizationPipeline",
+    "PassManager",
+    "Phi",
+    "PipelineBuilder",
+    "Return",
+    "StoreVar",
+    "Temp",
+    "UnaryOp",
+    "Variable",
+    "lower_to_mir",
+    "optimize_mir",
+    "optimize_mir_simple",
+]

machine_dialect/mir/analyses/__init__.py

@@ -0,0 +1,20 @@
+"""MIR analysis passes."""
+
+from machine_dialect.mir.analyses.alias_analysis import AliasAnalysis, AliasInfo
+from machine_dialect.mir.analyses.dominance_analysis import DominanceAnalysis
+from machine_dialect.mir.analyses.escape_analysis import EscapeAnalysis, EscapeInfo
+from machine_dialect.mir.analyses.loop_analysis import Loop, LoopAnalysis, LoopInfo
+from machine_dialect.mir.analyses.use_def_chains import UseDefChains, UseDefChainsAnalysis
+
+__all__ = [
+    "AliasAnalysis",
+    "AliasInfo",
+    "DominanceAnalysis",
+    "EscapeAnalysis",
+    "EscapeInfo",
+    "Loop",
+    "LoopAnalysis",
+    "LoopInfo",
+    "UseDefChains",
+    "UseDefChainsAnalysis",
+]