machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/compiler/compiler.py

@@ -0,0 +1,197 @@
+"""Main compiler module.
+
+This module provides the main Compiler class that manages the entire
+compilation process.
+"""
+
+from pathlib import Path
+
+from machine_dialect.compiler.config import CompilerConfig
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.compiler.pipeline import CompilationPipeline
+
+
+class Compiler:
+    """Main compiler class for Machine Dialect™.
+
+    Manages the entire compilation process from source files to bytecode,
+    including lexing, parsing, HIR/MIR generation, optimization, and
+    bytecode generation.
+
+    Attributes:
+        config: Compiler configuration settings.
+        pipeline: Compilation pipeline instance.
+    """
+
+    def __init__(self, config: CompilerConfig | None = None) -> None:
+        """Initialize the compiler.
+
+        Args:
+            config: Compiler configuration.
+        """
+        self.config = config or CompilerConfig()
+        self.pipeline = CompilationPipeline(self.config)
+
+    def compile_file(
+        self,
+        source_path: str | Path,
+        output_path: str | Path | None = None,
+    ) -> bool:
+        """Compile a Machine Dialect™ source file to bytecode.
+
+        Args:
+            source_path: Path to the .md source file to compile.
+            output_path: Optional output path for compiled bytecode.
+                If not provided, uses config default or derives from source.
+
+        Returns:
+            True if compilation succeeded without errors.
+
+        Raises:
+            FileNotFoundError: If source file doesn't exist.
+            PermissionError: If unable to write output file.
+        """
+        source_path = Path(source_path)
+
+        # Update output path in config if provided
+        if output_path:
+            self.config.output_path = Path(output_path)
+
+        # Run compilation pipeline
+        context = self.pipeline.compile_file(source_path)
+
+        # Print errors and warnings
+        context.print_errors_and_warnings()
+
+        # Check for errors
+        if context.has_errors():
+            return False
+
+        # Save compiled module if bytecode was generated
+        if context.bytecode_module and not self.config.mir_phase_only:
+            success = self._save_module(context)
+            if not success:
+                return False
+
+        # Show disassembly if requested
+        if self.config.verbose and context.bytecode_module:
+            self._show_disassembly(context)
+
+        # Print success message (but not for MIR-only mode)
+        if not self.config.mir_phase_only:
+            if self.config.verbose:
+                self._print_success(context)
+            else:
+                # Always print basic success message
+                output_path = context.get_output_path()
+                print(f"Successfully compiled to '{output_path}'")
+
+        return True
+
+    def compile_string(self, source: str, module_name: str = "__main__") -> CompilationContext:
+        """Compile a string of source code.
+
+        Args:
+            source: Source code string.
+            module_name: Name for the module.
+
+        Returns:
+            Compilation context with results.
+        """
+        # Create a context with dummy source path
+        context = CompilationContext(
+            source_path=Path("<string>"),
+            config=self.config,
+            source_content=source,
+        )
+
+        # Set module name
+        self.config.module_name = module_name
+
+        # Run compilation pipeline
+        return self.pipeline.compile(context)
+
+    def _save_module(self, context: CompilationContext) -> bool:
+        """Save compiled bytecode module to disk.
+
+        Args:
+            context: Compilation context containing bytecode module.
+
+        Returns:
+            True if save succeeded, False otherwise.
+
+        Note:
+            Errors during save are added to the compilation context.
+        """
+        if not context.bytecode_module:
+            return False
+
+        output_path = context.get_output_path()
+
+        try:
+            # Set module name
+            context.bytecode_module.name = context.get_module_name()
+
+            # Serialize and save using VM serializer
+            bytecode_data = context.bytecode_module.serialize()
+            with open(output_path, "wb") as f:
+                f.write(bytecode_data)
+
+            if self.config.verbose:
+                print(f"Wrote compiled module to {output_path}")
+
+            return True
+
+        except Exception as e:
+            context.add_error(f"Failed to save module: {e}")
+            return False
+
+    def _show_disassembly(self, context: CompilationContext) -> None:
+        """Display human-readable disassembly of compiled bytecode.
+
+        Args:
+            context: Compilation context containing bytecode module.
+
+        Note:
+            Currently placeholder - disassembly for register-based
+            bytecode is not yet implemented.
+        """
+        if not context.bytecode_module:
+            return
+
+        print("\n=== Disassembly ===")
+        # TODO: Implement disassembly for new register-based bytecode
+        print("Disassembly not yet implemented for register-based bytecode")
+
+    def _print_success(self, context: CompilationContext) -> None:
+        """Print detailed compilation success summary.
+
+        Args:
+            context: Compilation context containing statistics and results.
+
+        Note:
+            Only called when verbose mode is enabled in config.
+        """
+        stats = context.get_statistics()
+
+        print("\n=== Compilation Summary ===")
+        print(f"Source: {stats['source_file']}")
+        print(f"Module: {stats['module_name']}")
+
+        if "mir_functions" in stats:
+            print(f"Functions: {stats['mir_functions']}")
+
+        if "optimizations" in stats:
+            opt_stats = stats["optimizations"]
+            if opt_stats:
+                # opt_stats is a string summary, not a dict
+                if isinstance(opt_stats, str):
+                    # Just show that optimizations were applied
+                    print("Optimizations applied")
+                elif isinstance(opt_stats, dict):
+                    print(f"Optimizations applied: {opt_stats.get('total_transformations', 0)}")
+
+        if "bytecode_chunks" in stats:
+            print(f"Bytecode chunks: {stats['bytecode_chunks']}")
+
+        print("Compilation successful!")

machine_dialect/compiler/config.py

@@ -0,0 +1,149 @@
+"""Compiler configuration module.
+
+This module defines configuration options for the Machine Dialect™ compiler.
+"""
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+from pathlib import Path
+
+
+class OptimizationLevel(IntEnum):
+    """Optimization level enumeration."""
+
+    NONE = 0  # No optimizations
+    BASIC = 1  # Basic optimizations (constant folding, DCE)
+    STANDARD = 2  # Standard optimizations (default)
+    AGGRESSIVE = 3  # Aggressive optimizations (inlining, specialization)
+
+
+@dataclass
+class CompilerConfig:
+    """Compiler configuration settings.
+
+    Attributes:
+        optimization_level: Level of optimization to apply.
+        dump_mir: Whether to dump MIR representation.
+        dump_cfg: Path to export control flow graph.
+        show_optimization_report: Whether to show optimization report.
+        verbose: Enable verbose output.
+        debug: Enable debug mode.
+        profile_path: Path to profile data for PGO.
+        mir_phase_only: Stop after MIR generation.
+        output_path: Output file path.
+        module_name: Name for the compiled module.
+    """
+
+    optimization_level: OptimizationLevel = OptimizationLevel.STANDARD
+    dump_mir: bool = False
+    dump_cfg: Path | None = None
+    show_optimization_report: bool = False
+    verbose: bool = False
+    debug: bool = False
+    profile_path: Path | None = None
+    mir_phase_only: bool = False
+    output_path: Path | None = None
+    module_name: str | None = None
+
+    # MIR dumping options
+    mir_dump_verbosity: str = "normal"
+    mir_dump_phases: list[str] = field(default_factory=list)
+
+    # Optimization pass configuration
+    enabled_passes: list[str] | None = None
+    disabled_passes: list[str] | None = None
+    pass_pipeline: str | None = None  # Custom pass pipeline
+
+    @classmethod
+    def from_cli_options(
+        cls,
+        opt_level: str = "2",
+        dump_mir: bool = False,
+        show_cfg: str | None = None,
+        opt_report: bool = False,
+        verbose: bool = False,
+        debug: bool = False,
+        mir_phase: bool = False,
+        output: str | None = None,
+        module_name: str | None = None,
+        **kwargs: object,
+    ) -> "CompilerConfig":
+        """Create config from CLI options.
+
+        Args:
+            opt_level: Optimization level string.
+            dump_mir: Whether to dump MIR.
+            show_cfg: Path for CFG export.
+            opt_report: Whether to show optimization report.
+            verbose: Enable verbose output.
+            debug: Enable debug mode.
+            mir_phase: Stop after MIR generation.
+            output: Output file path.
+            module_name: Module name.
+            **kwargs: Additional options.
+
+        Returns:
+            Compiler configuration instance.
+        """
+        return cls(
+            optimization_level=OptimizationLevel(int(opt_level)),
+            dump_mir=dump_mir,
+            dump_cfg=Path(show_cfg) if show_cfg else None,
+            show_optimization_report=opt_report,
+            verbose=verbose,
+            debug=debug,
+            mir_phase_only=mir_phase,
+            output_path=Path(output) if output else None,
+            module_name=module_name,
+        )
+
+    def get_optimization_passes(self) -> list[str]:
+        """Get list of optimization passes to run based on level.
+
+        Returns:
+            List of optimization pass names.
+        """
+        if self.pass_pipeline:
+            return self.pass_pipeline.split(",")
+
+        passes = []
+
+        if self.optimization_level >= OptimizationLevel.BASIC:
+            passes.extend(
+                [
+                    "constant-folding",
+                    "constant-propagation",
+                    "dce",
+                    "simplify-cfg",
+                ]
+            )
+
+        if self.optimization_level >= OptimizationLevel.STANDARD:
+            passes.extend(
+                [
+                    "cse",
+                    "strength-reduction",
+                    "algebraic-simplification",  # New pass
+                    "licm",
+                    "loop-unrolling",
+                    "tail-call",
+                ]
+            )
+
+        if self.optimization_level >= OptimizationLevel.AGGRESSIVE:
+            passes.extend(
+                [
+                    "inlining",
+                    "type-specialization",
+                    "branch-prediction",
+                    "escape-analysis",
+                ]
+            )
+
+        # Filter based on enabled/disabled lists
+        if self.enabled_passes:
+            passes = [p for p in passes if p in self.enabled_passes]
+        if self.disabled_passes:
+            passes = [p for p in passes if p not in self.disabled_passes]
+
+        return passes

machine_dialect/compiler/context.py

@@ -0,0 +1,149 @@
+"""Compilation context module.
+
+This module manages the state and context throughout the compilation process.
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from machine_dialect.ast.ast_node import ASTNode
+from machine_dialect.codegen.bytecode_module import BytecodeModule
+from machine_dialect.compiler.config import CompilerConfig
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.profiling.profile_data import ProfileData
+from machine_dialect.mir.reporting.optimization_reporter import OptimizationReporter
+
+
+@dataclass
+class CompilationContext:
+    """Context for a single compilation session.
+
+    Attributes:
+        source_path: Path to source file being compiled.
+        config: Compiler configuration.
+        source_content: Source file content.
+        ast: Abstract syntax tree.
+        mir_module: MIR module.
+        bytecode_module: Bytecode module.
+        optimization_reporter: Optimization statistics reporter.
+        profile_data: Profile data for PGO.
+        errors: List of compilation errors.
+        warnings: List of compilation warnings.
+        metadata: Additional compilation metadata.
+    """
+
+    source_path: Path
+    config: CompilerConfig
+    source_content: str = ""
+    ast: ASTNode | None = None
+    mir_module: MIRModule | None = None
+    bytecode_module: BytecodeModule | None = None
+    optimization_reporter: OptimizationReporter | None = None
+    profile_data: ProfileData | None = None
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def add_error(self, message: str) -> None:
+        """Add a compilation error.
+
+        Args:
+            message: Error message.
+        """
+        self.errors.append(message)
+
+    def add_warning(self, message: str) -> None:
+        """Add a compilation warning.
+
+        Args:
+            message: Warning message.
+        """
+        self.warnings.append(message)
+
+    def has_errors(self) -> bool:
+        """Check if compilation has errors.
+
+        Returns:
+            True if there are errors.
+        """
+        return len(self.errors) > 0
+
+    def get_module_name(self) -> str:
+        """Get the module name for compilation.
+
+        Returns:
+            Module name.
+        """
+        if self.config.module_name:
+            return self.config.module_name
+        return self.source_path.stem
+
+    def get_output_path(self) -> Path:
+        """Get the output path for compiled module.
+
+        Returns:
+            Output file path.
+        """
+        if self.config.output_path:
+            return self.config.output_path
+        return self.source_path.with_suffix(".mdbc")
+
+    def should_optimize(self) -> bool:
+        """Check if optimization should be performed.
+
+        Returns:
+            True if optimization is enabled.
+        """
+        from machine_dialect.compiler.config import OptimizationLevel
+
+        return self.config.optimization_level > OptimizationLevel.NONE
+
+    def should_dump_mir(self) -> bool:
+        """Check if MIR should be dumped.
+
+        Returns:
+            True if MIR dumping is enabled.
+        """
+        return self.config.dump_mir or self.config.mir_phase_only
+
+    def should_generate_bytecode(self) -> bool:
+        """Check if bytecode generation should proceed.
+
+        Returns:
+            True if bytecode should be generated.
+        """
+        return not self.config.mir_phase_only
+
+    def print_errors_and_warnings(self) -> None:
+        """Print compilation errors and warnings."""
+        for warning in self.warnings:
+            print(f"Warning: {warning}")
+
+        for error in self.errors:
+            print(f"Error: {error}", file=__import__("sys").stderr)
+
+    def get_statistics(self) -> dict[str, Any]:
+        """Get compilation statistics.
+
+        Returns:
+            Dictionary of compilation statistics.
+        """
+        stats = {
+            "source_file": str(self.source_path),
+            "module_name": self.get_module_name(),
+            "errors": len(self.errors),
+            "warnings": len(self.warnings),
+        }
+
+        if self.mir_module:
+            stats["mir_functions"] = len(self.mir_module.functions)
+            stats["mir_globals"] = len(self.mir_module.globals)
+
+        if self.optimization_reporter:
+            stats["optimizations"] = self.optimization_reporter.generate_summary()
+
+        if self.bytecode_module:
+            stats["bytecode_chunks"] = len(self.bytecode_module.chunks)
+
+        return stats

machine_dialect/compiler/phases/__init__.py

@@ -0,0 +1,19 @@
+"""Compilation phases module.
+
+This module contains individual compilation phases that make up the
+compilation pipeline.
+"""
+
+from machine_dialect.compiler.phases.codegen import CodeGenerationPhase
+from machine_dialect.compiler.phases.hir_generation import HIRGenerationPhase
+from machine_dialect.compiler.phases.mir_generation import MIRGenerationPhase
+from machine_dialect.compiler.phases.optimization import OptimizationPhase
+from machine_dialect.compiler.phases.parsing import ParsingPhase
+
+__all__ = [
+    "CodeGenerationPhase",
+    "HIRGenerationPhase",
+    "MIRGenerationPhase",
+    "OptimizationPhase",
+    "ParsingPhase",
+]

machine_dialect/compiler/phases/bytecode_optimization.py

@@ -0,0 +1,90 @@
+"""Bytecode optimization phase.
+
+This module handles bytecode-level optimizations after code generation.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from machine_dialect.codegen.bytecode_module import BytecodeModule
+from machine_dialect.mir.optimizations.jump_threading import JumpThreadingOptimizer
+
+if TYPE_CHECKING:
+    from machine_dialect.compiler.context import CompilationContext
+
+
+class BytecodeOptimizationPhase:
+    """Bytecode optimization phase.
+
+    Applies bytecode-level optimizations like jump threading,
+    peephole optimization, etc.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the bytecode optimization phase."""
+        self.jump_threading = JumpThreadingOptimizer()
+
+    def run(self, context: CompilationContext, bytecode_module: BytecodeModule) -> BytecodeModule:
+        """Run bytecode optimizations.
+
+        Args:
+            context: Compilation context.
+            bytecode_module: Bytecode module to optimize.
+
+        Returns:
+            Optimized bytecode module.
+        """
+        if not context.should_optimize():
+            return bytecode_module
+
+        if context.config.verbose:
+            print("Running bytecode optimizations...")
+
+        # Apply jump threading to each chunk
+        optimized_chunks = []
+        total_stats = {
+            "jumps_threaded": 0,
+            "blocks_eliminated": 0,
+            "jumps_simplified": 0,
+            "blocks_merged": 0,
+        }
+
+        for chunk in bytecode_module.chunks:
+            # Reset optimizer for each chunk
+            self.jump_threading = JumpThreadingOptimizer()
+
+            # Optimize the chunk
+            optimized_chunk = self.jump_threading.optimize(chunk)
+            optimized_chunks.append(optimized_chunk)
+
+            # Accumulate statistics
+            stats = self.jump_threading.get_stats()
+            for key, value in stats.items():
+                total_stats[key] += value
+
+        # Create new module with optimized chunks
+        optimized_module = BytecodeModule(bytecode_module.name)
+        optimized_module.chunks = optimized_chunks
+        optimized_module.function_table = bytecode_module.function_table.copy()
+        optimized_module.global_names = bytecode_module.global_names.copy()
+        optimized_module.metadata = bytecode_module.metadata.copy()
+
+        # Report optimization results
+        if context.config.verbose and any(total_stats.values()):
+            print("\n=== Bytecode Optimization Results ===")
+            if total_stats["jumps_threaded"] > 0:
+                print(f"  Jumps threaded: {total_stats['jumps_threaded']}")
+            if total_stats["blocks_eliminated"] > 0:
+                print(f"  Dead blocks eliminated: {total_stats['blocks_eliminated']}")
+            if total_stats["jumps_simplified"] > 0:
+                print(f"  Conditional jumps simplified: {total_stats['jumps_simplified']}")
+            if total_stats["blocks_merged"] > 0:
+                print(f"  Blocks merged: {total_stats['blocks_merged']}")
+            print()
+
+        # Store stats in context for reporting
+        if context.optimization_reporter:
+            context.optimization_reporter.add_custom_stats("bytecode_optimization", total_stats)
+
+        return optimized_module

machine_dialect/compiler/phases/codegen.py

@@ -0,0 +1,40 @@
+"""Register-based code generation phase.
+
+This module handles the register-based bytecode generation for the new Rust VM.
+"""
+
+from machine_dialect.codegen.bytecode_module import BytecodeModule
+from machine_dialect.codegen.register_codegen import RegisterBytecodeGenerator
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.mir.mir_module import MIRModule
+
+
+class CodeGenerationPhase:
+    """Register-based bytecode generation phase."""
+
+    def run(self, context: CompilationContext, mir_module: MIRModule) -> BytecodeModule | None:
+        """Run code generation phase.
+
+        Args:
+            context: Compilation context.
+            mir_module: MIR module to generate code from.
+
+        Returns:
+            Bytecode module or None if generation failed.
+        """
+        try:
+            # Create bytecode generator with debug if verbose mode is on
+            debug = context.config.verbose if context.config else False
+            generator = RegisterBytecodeGenerator(debug=debug)
+
+            # Generate bytecode from MIR
+            bytecode_module = generator.generate(mir_module)
+
+            # Store in context
+            context.bytecode_module = bytecode_module
+
+            return bytecode_module
+
+        except Exception as e:
+            context.add_error(f"Code generation failed: {e}")
+            return None

machine_dialect/compiler/phases/hir_generation.py

@@ -0,0 +1,39 @@
+"""HIR generation phase of compilation.
+
+This module handles the High-level IR generation (desugaring) phase.
+"""
+
+from machine_dialect.ast.ast_node import ASTNode
+from machine_dialect.compiler.context import CompilationContext
+
+
+class HIRGenerationPhase:
+    """HIR generation (desugaring) phase."""
+
+    def run(self, context: CompilationContext, ast: ASTNode) -> ASTNode:
+        """Run HIR generation phase.
+
+        Converts AST to HIR by applying desugaring and canonicalization
+        transformations using the to_hir method.
+
+        Args:
+            context: Compilation context.
+            ast: Abstract syntax tree.
+
+        Returns:
+            HIR representation with desugared and canonicalized nodes.
+        """
+        if context.config.verbose:
+            print("Generating HIR")
+
+        # Use to_hir to convert AST to HIR
+        # The ast should be a Program which has to_hir method
+        from machine_dialect.ast.program import Program
+
+        assert isinstance(ast, Program), "HIR generation expects a Program node"
+        hir = ast.to_hir()
+
+        if context.config.verbose:
+            print("HIR generation complete")
+
+        return hir