machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/compiler/phases/mir_generation.py

@@ -0,0 +1,86 @@
+"""MIR generation phase of compilation.
+
+This module handles the MIR lowering phase of compilation.
+"""
+
+from machine_dialect.ast.ast_node import ASTNode
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.mir.hir_to_mir import lower_to_mir
+from machine_dialect.mir.mir_dumper import DumpVerbosity, MIRDumper
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.mir_printer import MIRDotExporter
+
+
+class MIRGenerationPhase:
+    """MIR generation phase."""
+
+    def run(self, context: CompilationContext, hir: ASTNode) -> MIRModule | None:
+        """Run MIR generation phase.
+
+        Args:
+            context: Compilation context.
+            hir: High-level IR (currently AST).
+
+        Returns:
+            MIR module or None if generation failed.
+        """
+        if context.config.verbose:
+            print("Lowering to MIR...")
+
+        try:
+            # Pass module name if available
+            module_name = context.get_module_name()
+            mir_module = lower_to_mir(hir, module_name)  # type: ignore[arg-type]
+
+            if context.config.verbose:
+                print(f"Generated MIR with {len(mir_module.functions)} functions")
+
+            # Dump MIR if requested
+            if context.config.dump_mir and not context.config.mir_phase_only:
+                self._dump_mir(mir_module, "initial", context)
+
+            # Export CFG if requested
+            if context.config.dump_cfg:
+                self._export_cfg(mir_module, context)
+
+            return mir_module
+
+        except Exception as e:
+            context.add_error(f"MIR generation error: {e}")
+            return None
+
+    def _dump_mir(self, module: MIRModule, phase: str, context: CompilationContext) -> None:
+        """Dump MIR representation.
+
+        Args:
+            module: MIR module to dump.
+            phase: Phase name for labeling.
+            context: Compilation context.
+        """
+        verbosity = DumpVerbosity.from_string(context.config.mir_dump_verbosity)
+        dumper = MIRDumper(verbosity=verbosity, use_color=True)
+
+        if phase == "initial":
+            print("\n=== MIR Representation ===")
+        else:
+            print(f"\n=== MIR ({phase}) ===")
+        dumper.dump_module(module)
+
+    def _export_cfg(self, module: MIRModule, context: CompilationContext) -> None:
+        """Export control flow graph.
+
+        Args:
+            module: MIR module.
+            context: Compilation context.
+        """
+        if not context.config.dump_cfg:
+            return
+
+        exporter = MIRDotExporter()
+        dot_content = exporter.export_module(module)
+
+        with open(context.config.dump_cfg, "w") as f:
+            f.write(dot_content)
+
+        # Always print CFG export message (not just in verbose mode)
+        print(f"Control flow graph exported to '{context.config.dump_cfg}'")

machine_dialect/compiler/phases/optimization.py

@@ -0,0 +1,110 @@
+"""Optimization phase of compilation.
+
+This module handles the optimization phase of compilation.
+"""
+
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.mir.mir_dumper import DumpVerbosity, MIRDumper
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.optimize_mir import optimize_mir
+from machine_dialect.mir.profiling.profile_reader import ProfileReader
+from machine_dialect.mir.reporting.optimization_reporter import OptimizationReporter
+
+
+class OptimizationPhase:
+    """Optimization phase."""
+
+    def run(self, context: CompilationContext, mir_module: MIRModule) -> MIRModule:
+        """Run optimization phase.
+
+        Args:
+            context: Compilation context.
+            mir_module: MIR module to optimize.
+
+        Returns:
+            Optimized MIR module.
+        """
+        if not context.should_optimize():
+            if context.config.verbose:
+                print("Skipping optimization (level 0)")
+            return mir_module
+
+        if context.config.verbose:
+            print(f"Running optimization level {context.config.optimization_level}...")
+
+        # Load profile data if available
+        profile_data = None
+        if context.config.profile_path and context.config.profile_path.exists():
+            reader = ProfileReader()
+            profile_data = reader.read_from_file(str(context.config.profile_path))  # type: ignore[attr-defined]
+            context.profile_data = profile_data
+            if context.config.verbose:
+                print(f"Loaded profile data from {context.config.profile_path}")
+
+        # Create optimization reporter
+        reporter = OptimizationReporter() if context.config.show_optimization_report else None
+        context.optimization_reporter = reporter
+
+        # Get optimization passes
+        passes = context.config.get_optimization_passes()
+
+        if context.config.verbose:
+            print(f"Running passes: {', '.join(passes)}")
+
+        # Create optimization config
+        from machine_dialect.mir.optimization_config import OptimizationConfig
+
+        opt_config = OptimizationConfig.from_level(int(context.config.optimization_level))
+
+        # Apply custom pass list if provided
+        custom_passes = None
+        if context.config.pass_pipeline:
+            custom_passes = passes
+
+        # Run optimization
+        optimized_module, stats = optimize_mir(
+            mir_module,
+            optimization_level=int(context.config.optimization_level),
+            config=opt_config,
+            debug=context.config.debug,
+            custom_passes=custom_passes,
+        )
+
+        # Store stats in reporter if provided
+        if reporter and stats:
+            for pass_name, pass_stats in stats.items():
+                reporter.start_pass(pass_name)
+                reporter.end_pass(metrics=pass_stats)
+
+        # Dump optimized MIR if requested
+        if context.config.dump_mir:
+            self._dump_mir(optimized_module, "optimized", context)
+
+        # Show optimization report if requested
+        if context.config.show_optimization_report and reporter:
+            self._show_optimization_report(reporter)
+
+        return optimized_module
+
+    def _dump_mir(self, module: MIRModule, phase: str, context: CompilationContext) -> None:
+        """Dump MIR representation.
+
+        Args:
+            module: MIR module to dump.
+            phase: Phase name for labeling.
+            context: Compilation context.
+        """
+        verbosity = DumpVerbosity.from_string(context.config.mir_dump_verbosity)
+        dumper = MIRDumper(verbosity=verbosity, use_color=True)
+
+        print(f"\n=== MIR ({phase}) ===")
+        dumper.dump_module(module)
+
+    def _show_optimization_report(self, reporter: OptimizationReporter) -> None:
+        """Show optimization report.
+
+        Args:
+            reporter: Optimization reporter.
+        """
+        print("\n=== Optimization Report ===")
+        print(reporter.generate_detailed_report())

machine_dialect/compiler/phases/parsing.py

@@ -0,0 +1,39 @@
+"""Parsing phase of compilation.
+
+This module handles the syntactic analysis phase of compilation.
+"""
+
+from machine_dialect.ast.ast_node import ASTNode
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.parser.parser import Parser
+
+
+class ParsingPhase:
+    """Syntactic analysis phase."""
+
+    def run(self, context: CompilationContext) -> ASTNode | None:
+        """Run parsing phase.
+
+        Args:
+            context: Compilation context.
+
+        Returns:
+            AST root node or None if parsing failed.
+        """
+        if context.config.verbose:
+            print("Parsing source into AST...")
+
+        parser = Parser()
+
+        ast = parser.parse(context.source_content)
+
+        # Check for parsing errors
+        if parser.has_errors():
+            for error in parser.errors:
+                context.add_error(f"Parse error: {error}")
+            return None
+
+        if context.config.verbose:
+            print("Successfully parsed AST")
+
+        return ast

machine_dialect/compiler/pipeline.py

@@ -0,0 +1,143 @@
+"""Compilation pipeline module.
+
+This module orchestrates the entire compilation process through its phases.
+"""
+
+from pathlib import Path
+
+from machine_dialect.compiler.config import CompilerConfig
+from machine_dialect.compiler.context import CompilationContext
+from machine_dialect.compiler.phases.bytecode_optimization import BytecodeOptimizationPhase
+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
+from machine_dialect.mir.mir_dumper import DumpVerbosity, MIRDumper
+
+
+class CompilationPipeline:
+    """Manages the compilation pipeline."""
+
+    def __init__(self, config: CompilerConfig | None = None) -> None:
+        """Initialize the compilation pipeline.
+
+        Args:
+            config: Compiler configuration.
+        """
+        self.config = config or CompilerConfig()
+
+        # Initialize phases
+        self.parsing_phase = ParsingPhase()
+        self.hir_phase = HIRGenerationPhase()
+        self.mir_phase = MIRGenerationPhase()
+        self.optimization_phase = OptimizationPhase()
+        self.codegen_phase = CodeGenerationPhase()
+        self.bytecode_optimization_phase = BytecodeOptimizationPhase()
+
+    def compile_file(self, source_path: Path) -> CompilationContext:
+        """Compile a source file.
+
+        Args:
+            source_path: Path to source file.
+
+        Returns:
+            Compilation context with results.
+        """
+        # Create compilation context
+        context = CompilationContext(source_path=source_path, config=self.config)
+
+        # Read source file
+        try:
+            context.source_content = source_path.read_text()
+        except OSError as e:
+            context.add_error(f"Failed to read source file: {e}")
+            return context
+
+        # Run compilation pipeline
+        return self.compile(context)
+
+    def compile(self, context: CompilationContext) -> CompilationContext:
+        """Run the compilation pipeline.
+
+        Args:
+            context: Compilation context.
+
+        Returns:
+            Updated compilation context.
+        """
+        # Print "Compiling" message if verbose
+        if context.config.verbose:
+            print(f"Compiling {context.source_path}...")
+
+        # Phase 1: Syntactic Analysis (includes lexical analysis)
+        if not context.has_errors():
+            ast = self.parsing_phase.run(context)
+            if ast:
+                context.ast = ast
+            else:
+                return context
+        else:
+            return context
+
+        # Phase 2: HIR Generation (Desugaring)
+        if not context.has_errors():
+            hir = self.hir_phase.run(context, context.ast)
+        else:
+            return context
+
+        # Phase 3: MIR Generation
+        if not context.has_errors():
+            mir_module = self.mir_phase.run(context, hir)
+            if mir_module:
+                context.mir_module = mir_module
+            else:
+                return context
+        else:
+            return context
+
+        # Check if we should stop after MIR
+        if context.config.mir_phase_only:
+            self._dump_final_mir(context)
+            print("Stopping after MIR generation (--mir-phase flag)")
+            return context
+
+        # Phase 4: Optimization
+        if not context.has_errors() and context.should_optimize():
+            optimized_mir = self.optimization_phase.run(context, context.mir_module)
+            context.mir_module = optimized_mir
+        else:
+            if context.has_errors():
+                return context
+
+        # Phase 5: Code Generation
+        if not context.has_errors() and context.should_generate_bytecode():
+            bytecode_module = self.codegen_phase.run(context, context.mir_module)
+            if bytecode_module:
+                context.bytecode_module = bytecode_module
+            else:
+                return context
+        else:
+            return context
+
+        # Phase 6: Bytecode Optimization (after code generation)
+        if not context.has_errors() and context.bytecode_module and context.should_optimize():
+            optimized_bytecode = self.bytecode_optimization_phase.run(context, context.bytecode_module)
+            context.bytecode_module = optimized_bytecode
+
+        return context
+
+    def _dump_final_mir(self, context: CompilationContext) -> None:
+        """Dump final MIR when stopping at MIR phase.
+
+        Args:
+            context: Compilation context.
+        """
+        if not context.mir_module:
+            return
+
+        verbosity = DumpVerbosity.from_string(context.config.mir_dump_verbosity)
+        dumper = MIRDumper(verbosity=verbosity, use_color=True)
+
+        print("\n=== Final MIR ===")
+        dumper.dump_module(context.mir_module)

machine_dialect/compiler/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Machine Dialect™ compiler module."""