feat: implement AST mutation to apply inferred types from type resolver

This implements the proper architectural solution for Type::Any resolution
by applying resolved types from the InferenceContext back to the TypedAST
after type checking completes. This ensures all language implementations
benefit from type inference, not just ZynPEG.

Changes:
- Add apply_inferred_types() method to TypeChecker that walks TypedProgram
  and replaces Type::Any with resolved types from inference substitutions
- Update lowering pipeline to call apply_inferred_types() after type checking
- Change lower_program() signatures throughout to accept &mut TypedProgram
- Update compile_to_hir() and compile_to_jit() public APIs to use mutable refs
- Remove SKIP_TYPE_CHECK bypass from zyntax_embed runtime to enable type resolution
- Fix all test files to pass mutable program references

Architecture:
Parser → TypedAST (Type::Any) → Type Checker → Inference solves constraints →
apply_inferred_types() mutates AST → Lowering (fully resolved types)

Author: darmie

crates/compiler/src/lib.rs

@@ -173,7 +173,7 @@ impl Default for CompilationConfig {
 /// 4. Run optimization passes
 /// 5. Return optimized HIR ready for backend code generation
 pub fn compile_to_hir(
-    program: &TypedProgram,
+    program: &mut TypedProgram,
     type_registry: Arc<zyntax_typed_ast::TypeRegistry>,
     config: CompilationConfig,
 ) -> CompilerResult<HirModule> {
@@ -300,7 +300,7 @@ pub fn compile_to_hir(
 /// 3. Returns a Cranelift backend ready to execute functions
 #[cfg(feature = "cranelift")]
 pub fn compile_to_jit(
-    program: &TypedProgram,
+    program: &mut TypedProgram,
     type_registry: Arc<zyntax_typed_ast::TypeRegistry>,
     config: CompilationConfig,
 ) -> CompilerResult<cranelift_backend::CraneliftBackend> {

crates/compiler/src/lowering.rs

@@ -328,7 +328,7 @@ pub enum DiagnosticLevel {
 /// Main AST lowering interface
 pub trait AstLowering {
     /// Lower a typed program to HIR
-    fn lower_program(&mut self, program: &TypedProgram) -> CompilerResult<HirModule>;
+    fn lower_program(&mut self, program: &mut TypedProgram) -> CompilerResult<HirModule>;
 }
 
 /// Lowering pipeline implementation
@@ -382,7 +382,7 @@ impl LoweringContext {
 }
 
 impl AstLowering for LoweringContext {
-    fn lower_program(&mut self, program: &TypedProgram) -> CompilerResult<HirModule> {
+    fn lower_program(&mut self, program: &mut TypedProgram) -> CompilerResult<HirModule> {
         // Phase 0: Run type checking and inference (Issue 0 Phase 1)
         // This validates types and performs type inference, reporting any errors
         // Skip type checking if SKIP_TYPE_CHECK env var is set (for debugging)
@@ -416,7 +416,7 @@ impl AstLowering for LoweringContext {
 impl LoweringContext {
     /// Run type checking and inference on the program
     /// This is Issue 0 Phase 1: integrate type inference into lowering
-    fn run_type_checking(&mut self, program: &TypedProgram) -> CompilerResult<()> {
+    fn run_type_checking(&mut self, program: &mut TypedProgram) -> CompilerResult<()> {
         use zyntax_typed_ast::type_checker::{TypeChecker, TypeCheckOptions};
 
         // Create type checker - needs Box<TypeRegistry>
@@ -431,6 +431,10 @@ impl LoweringContext {
         // Run type checking (validates and performs internal inference)
         type_checker.check_program(program);
 
+        // Apply resolved types from inference to the AST
+        // This propagates Type::Any resolutions back to the AST nodes
+        type_checker.apply_inferred_types(program);
+
         // Check for type errors and display diagnostics
         let diagnostics_collector = type_checker.diagnostics();
         let error_count = diagnostics_collector.error_count();

crates/compiler/tests/compilation_pipeline_tests.rs

@@ -78,7 +78,7 @@ fn test_compilation_pipeline_simple_function() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "return_42", body);
+    let mut program = create_test_program(&mut arena, "return_42", body);
 
     // Run compilation pipeline
     let config = CompilationConfig {
@@ -88,7 +88,7 @@ fn test_compilation_pipeline_simple_function() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation should succeed: {:?}", result.err());
 
     let hir_module = result.unwrap();
@@ -153,7 +153,7 @@ fn test_compilation_pipeline_binary_operation() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "add_numbers", body);
+    let mut program = create_test_program(&mut arena, "add_numbers", body);
 
     // Run compilation pipeline
     let config = CompilationConfig {
@@ -163,7 +163,7 @@ fn test_compilation_pipeline_binary_operation() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation should succeed: {:?}", result.err());
 
     let hir_module = result.unwrap();
@@ -328,7 +328,7 @@ fn test_compilation_pipeline_with_analysis() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_analysis", body);
+    let mut program = create_test_program(&mut arena, "test_analysis", body);
 
     // Run compilation with all passes enabled
     let config = CompilationConfig {
@@ -338,7 +338,7 @@ fn test_compilation_pipeline_with_analysis() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation with analysis should succeed");
 
     let hir_module = result.unwrap();
@@ -370,7 +370,7 @@ fn test_compilation_pipeline_with_memory_management() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_memory", body);
+    let mut program = create_test_program(&mut arena, "test_memory", body);
 
     // Run compilation with ARC memory strategy
     let config = CompilationConfig {
@@ -381,7 +381,7 @@ fn test_compilation_pipeline_with_memory_management() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation with ARC should succeed");
 
     let hir_module = result.unwrap();
@@ -411,7 +411,7 @@ fn test_compilation_pipeline_without_memory_management() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_no_memory", body);
+    let mut program = create_test_program(&mut arena, "test_no_memory", body);
 
     // Run compilation with memory management disabled
     let config = CompilationConfig {
@@ -422,7 +422,7 @@ fn test_compilation_pipeline_without_memory_management() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation without memory management should succeed");
 
     let hir_module = result.unwrap();
@@ -452,7 +452,7 @@ fn test_compilation_pipeline_with_gc_strategy() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_gc", body);
+    let mut program = create_test_program(&mut arena, "test_gc", body);
 
     // Run compilation with GC memory strategy
     let config = CompilationConfig {
@@ -463,7 +463,7 @@ fn test_compilation_pipeline_with_gc_strategy() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation with GC should succeed");
 
     let hir_module = result.unwrap();
@@ -509,7 +509,7 @@ fn test_compilation_pipeline_all_features() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_all_features", body);
+    let mut program = create_test_program(&mut arena, "test_all_features", body);
 
     // Run compilation with ALL features enabled
     let config = CompilationConfig {
@@ -523,7 +523,7 @@ fn test_compilation_pipeline_all_features() {
         import_resolver: None,
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation with all features should succeed");
 
     let hir_module = result.unwrap();
@@ -576,7 +576,7 @@ fn test_compilation_pipeline_with_memory_optimizations() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_opt", body);
+    let mut program = create_test_program(&mut arena, "test_opt", body);
 
     // Run compilation with full optimization including memory optimizations
     let config = CompilationConfig {
@@ -590,7 +590,7 @@ fn test_compilation_pipeline_with_memory_optimizations() {
         import_resolver: None,
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Compilation with memory optimizations should succeed");
 
     let hir_module = result.unwrap();
@@ -658,7 +658,7 @@ fn test_compilation_pipeline_with_async_function() -> CompilerResult<()> {
         ..Default::default()
     };
 
-    let hir_module = compile_to_hir(&program, type_registry, config)?;
+    let hir_module = compile_to_hir(&mut program, type_registry, config)?;
 
     // Verify module was created
     // Async functions generate additional state machine functions, so we expect >= 1
@@ -728,7 +728,7 @@ fn test_compilation_pipeline_without_async_runtime() -> CompilerResult<()> {
         ..Default::default()
     };
 
-    let hir_module = compile_to_hir(&program, type_registry, config)?;
+    let hir_module = compile_to_hir(&mut program, type_registry, config)?;
 
     // Verify module was created
     assert!(hir_module.functions.len() >= 1, "Should have at least one function");
@@ -835,7 +835,7 @@ fn test_compilation_pipeline_mixed_sync_async() -> CompilerResult<()> {
         ..Default::default()
     };
 
-    let hir_module = compile_to_hir(&program, type_registry, config)?;
+    let hir_module = compile_to_hir(&mut program, type_registry, config)?;
 
     // Verify both functions were created
     // Async functions may generate additional state machine functions
@@ -879,7 +879,7 @@ fn test_compilation_pipeline_while_loop() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_while", body);
+    let mut program = create_test_program(&mut arena, "test_while", body);
 
     let config = CompilationConfig {
         opt_level: 0,
@@ -888,7 +888,7 @@ fn test_compilation_pipeline_while_loop() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "While loop compilation should succeed: {:?}", result.err());
 
     let hir_module = result.unwrap();
@@ -937,7 +937,7 @@ fn test_compilation_pipeline_infinite_loop_with_break() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_loop_break", body);
+    let mut program = create_test_program(&mut arena, "test_loop_break", body);
 
     let config = CompilationConfig {
         opt_level: 0,
@@ -946,7 +946,7 @@ fn test_compilation_pipeline_infinite_loop_with_break() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Infinite loop with break should compile: {:?}", result.err());
 
     let hir_module = result.unwrap();
@@ -978,7 +978,7 @@ fn test_compilation_pipeline_nested_blocks() {
         span: test_span(),
     };
 
-    let program = create_test_program(&mut arena, "test_nested_blocks", outer_block);
+    let mut program = create_test_program(&mut arena, "test_nested_blocks", outer_block);
 
     let config = CompilationConfig {
         opt_level: 0,
@@ -987,7 +987,7 @@ fn test_compilation_pipeline_nested_blocks() {
         ..Default::default()
     };
 
-    let result = compile_to_hir(&program, type_registry, config);
+    let result = compile_to_hir(&mut program, type_registry, config);
     assert!(result.is_ok(), "Nested blocks should compile: {:?}", result.err());
 
     let hir_module = result.unwrap();

crates/compiler/tests/expression_lowering_tests.rs

@@ -107,7 +107,7 @@ fn test_literal_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower literal expression: {:?}", result.err());
 
     let module = result.unwrap();
@@ -166,7 +166,7 @@ fn test_binary_operation_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower binary operation: {:?}", result.err());
 
     let module = result.unwrap();
@@ -232,7 +232,7 @@ fn test_unary_operation_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower unary operation: {:?}", result.err());
 
     let module = result.unwrap();
@@ -311,7 +311,7 @@ fn test_if_expression_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower if expression: {:?}", result.err());
 
     let module = result.unwrap();
@@ -386,7 +386,7 @@ fn test_variable_reference_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower variable reference: {:?}", result.err());
 }
 
@@ -448,7 +448,7 @@ fn test_tuple_construction_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower tuple construction: {:?}", result.err());
 
     let module = result.unwrap();
@@ -529,7 +529,7 @@ fn test_array_construction_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower array construction: {:?}", result.err());
 }
 
@@ -601,7 +601,7 @@ fn test_complex_expression_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower complex expression: {:?}", result.err());
 
     let module = result.unwrap();
@@ -827,7 +827,7 @@ fn test_assignment_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower assignment expression: {:?}", result.err());
 
     let module = result.unwrap();
@@ -960,7 +960,7 @@ fn test_pattern_matching_lowering() {
         config,
     );
 
-    let result = ctx.lower_program(&program);
+    let result = ctx.lower_program(&mut program);
     assert!(result.is_ok(), "Failed to lower match expression: {:?}", result.err());
 
     let module = result.unwrap();