fix: implement proper source location tracking in diagnostics

- Add source_files field to TypedProgram to carry source information
- Add span tracking to zyntax_embed parsing path (walk_parse_tree/walk_pair_to_value)
- Add set_current_span() method to AstHostFunctions trait with default impl
- Implement set_current_span() in TypedAstBuilder to track current parsing position
- Add parse_to_json_with_filename() method to LanguageGrammar
- Update ZynML::run_file() to use load_module_file() for proper filename tracking
- Populate SourceMap from program.source_files in lowering diagnostics
- Update ConsoleDiagnosticDisplay to show real source code and accurate spans

Diagnostics now show:
- Real filenames instead of "unknown.zy"
- Accurate line and column numbers from source
- Actual source code snippets
- Proper multi-character span underlines

Fixes issue where all errors showed position 1:1 with placeholder text.

Author: darmie

crates/compiler/src/lowering.rs

@@ -443,8 +443,11 @@ impl LoweringContext {
 
             eprintln!("\n=== Type Checking Diagnostics ===");
 
-            // Create a source map (empty for now since we don't have source files in tests)
-            let source_map = SourceMap::new();
+            // Create a source map and populate it with source files from the program
+            let mut source_map = SourceMap::new();
+            for source_file in &program.source_files {
+                source_map.add_file(source_file.name.clone(), source_file.content.clone());
+            }
             let display = ConsoleDiagnosticDisplay::default();
 
             // Use the built-in pretty formatter

crates/typed_ast/src/ast_convert.rs

@@ -230,6 +230,7 @@ pub mod typescript_example {
             Ok(TypedProgram {
                 declarations,
                 span: Span::new(0, 0), // Would get from source
+                source_files: vec![], // TODO: Add source file info
             })
         }
     }

crates/typed_ast/src/diagnostics.rs

@@ -331,35 +331,65 @@ impl DiagnosticDisplay for ConsoleDiagnosticDisplay {
 
         // Group annotations by file and sort by line
         let mut file_annotations: HashMap<String, Vec<&Annotation>> = HashMap::new();
+
+        // Get the first source file name from the source map (for single-file programs)
+        // TODO: For multi-file programs, track file_id in Span
+        let default_filename = source_map.get_file_by_id(0)
+            .map(|f| f.name.clone())
+            .unwrap_or_else(|| "input.zy".to_string());
+
         for annotation in &diagnostic.annotations {
-            // For now, use a placeholder filename - in practice, get from source_map
-            let filename = "input.zy".to_string(); // source_map.get_filename(annotation.span)
-            file_annotations.entry(filename).or_default().push(annotation);
+            file_annotations.entry(default_filename.clone()).or_default().push(annotation);
         }
-        
+
         // Display each file's annotations
         for (filename, annotations) in file_annotations {
-            writeln!(f, "  --> {}:{}:{}", filename, 1, 1)?; // Placeholder line/column
-            writeln!(f, "   |")?;
-            
+            // Get the source file
+            let source_file = source_map.get_file(&filename);
+
             // Sort annotations by span start
             let mut sorted_annotations = annotations;
             sorted_annotations.sort_by_key(|a| a.span.start);
-            
+
             // Display source lines with annotations
             for annotation in sorted_annotations {
-                // Placeholder source line display
-                writeln!(f, "{:3} | {}", 1, "    // source code line here")?;
-                writeln!(f, "   | {}{}",
-                    " ".repeat(4), // Column offset
-                    self.format_underline(annotation.style, 10) // Underline length
-                )?;
-                
-                if let Some(message) = &annotation.message {
-                    writeln!(f, "   | {}{}", " ".repeat(4), message)?;
+                // Get the actual location and source line
+                if let Some(file) = source_file {
+                    let location = file.get_location(annotation.span.start);
+                    let source_line = file.get_line(location.line).unwrap_or("");
+
+                    writeln!(f, "  --> {}:{}:{}", filename, location.line, location.column)?;
+                    writeln!(f, "   |")?;
+                    writeln!(f, "{:3} | {}", location.line, source_line)?;
+
+                    // Calculate underline position and length
+                    let underline_start = location.column - 1; // Convert to 0-based
+                    let underline_len = annotation.span.len().max(1);
+
+                    writeln!(f, "   | {}{}",
+                        " ".repeat(underline_start),
+                        self.format_underline(annotation.style, underline_len)
+                    )?;
+
+                    if let Some(message) = &annotation.message {
+                        writeln!(f, "   | {}{}", " ".repeat(underline_start), message)?;
+                    }
+                } else {
+                    // Fallback to placeholder if source file not found
+                    writeln!(f, "  --> {}:{}:{}", filename, 1, 1)?;
+                    writeln!(f, "   |")?;
+                    writeln!(f, "{:3} | {}", 1, "    // source code line here")?;
+                    writeln!(f, "   | {}{}",
+                        " ".repeat(4),
+                        self.format_underline(annotation.style, 10)
+                    )?;
+
+                    if let Some(message) = &annotation.message {
+                        writeln!(f, "   | {}{}", " ".repeat(4), message)?;
+                    }
                 }
             }
-            
+
             writeln!(f, "   |")?;
         }
 

crates/typed_ast/src/typed_ast.rs

@@ -10,7 +10,7 @@
 //! - Supports languages like Rust, Java, C#, TypeScript, and Haxe
 
 use crate::arena::InternedString;
-use crate::source::Span;
+use crate::source::{Span, SourceFile};
 use crate::type_registry::{Type, Mutability, Visibility, CallingConvention};
 use serde::{Deserialize, Serialize};
 
@@ -39,11 +39,24 @@ impl<T: Default> Default for TypedNode<T> {
 }
 
 /// Typed program - the root of the AST
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TypedProgram {
     pub declarations: Vec<TypedNode<TypedDeclaration>>,
     #[serde(default)]
     pub span: Span,
+    /// Source files used in this program (for diagnostics)
+    #[serde(default)]
+    pub source_files: Vec<SourceFile>,
+}
+
+impl Default for TypedProgram {
+    fn default() -> Self {
+        Self {
+            declarations: Vec::new(),
+            span: Span::default(),
+            source_files: Vec::new(),
+        }
+    }
 }
 
 /// Top-level declarations

crates/typed_ast/src/typed_builder.rs

@@ -18,16 +18,36 @@ use crate::type_registry::TypeRegistry;
 pub struct TypedASTBuilder {
     arena: AstArena,
     pub registry: TypeRegistry,
+    source_file: Option<String>,
+    source_content: Option<String>,
 }
 
 impl TypedASTBuilder {
     pub fn new() -> Self {
         Self {
             arena: AstArena::new(),
             registry: TypeRegistry::new(),
+            source_file: None,
+            source_content: None,
         }
     }
 
+    /// Set the source file information for span tracking
+    pub fn set_source(&mut self, file_name: String, content: String) {
+        self.source_file = Some(file_name);
+        self.source_content = Some(content);
+    }
+
+    /// Get the source file name
+    pub fn source_file(&self) -> Option<&str> {
+        self.source_file.as_deref()
+    }
+
+    /// Get the source content
+    pub fn source_content(&self) -> Option<&str> {
+        self.source_content.as_deref()
+    }
+
     /// Get a reference to the arena for string interning
     pub fn arena(&mut self) -> &mut AstArena {
         &mut self.arena
@@ -1153,7 +1173,16 @@ impl TypedASTBuilder {
         declarations: Vec<TypedNode<TypedDeclaration>>,
         span: Span,
     ) -> TypedProgram {
-        TypedProgram { declarations, span }
+        use crate::source::SourceFile;
+
+        // Create SourceFile if we have source information
+        let source_files = if let (Some(name), Some(content)) = (self.source_file(), self.source_content()) {
+            vec![SourceFile::new(name.to_string(), content.to_string())]
+        } else {
+            vec![]
+        };
+
+        TypedProgram { declarations, span, source_files }
     }
 }
 

crates/whirlwind_adapter/src/adapter.rs

@@ -182,6 +182,7 @@ impl WhirlwindAdapter {
         let mut program = TypedProgram {
             declarations: all_declarations,
             span,
+            source_files: vec![],
         };
 
         // Run our type inference engine to fill in Unknown types

crates/zyn_peg/src/runtime.rs

@@ -243,6 +243,11 @@ pub trait AstHostFunctions {
     /// Finalize program and return serialized TypedAST JSON
     fn finalize_program(&mut self, program: NodeHandle) -> String;
 
+    /// Set the current source span for tracking locations
+    fn set_current_span(&mut self, _start: usize, _end: usize) {
+        // Default implementation does nothing - can be overridden
+    }
+
     // ========== Functions ==========
 
     /// Create a function declaration
@@ -1102,6 +1107,8 @@ pub struct TypedAstBuilder {
     enum_types: HashMap<String, Vec<String>>,
     /// Program declaration handles (in order)
     program_decls: Vec<NodeHandle>,
+    /// Current span being processed (start, end)
+    current_span: (usize, usize),
 }
 
 impl Default for TypedAstBuilder {
@@ -1131,9 +1138,25 @@ impl TypedAstBuilder {
             variable_types: HashMap::new(),
             enum_types: HashMap::new(),
             program_decls: Vec::new(),
+            current_span: (0, 0),
         }
     }
 
+    /// Set the current span for the next node being created
+    pub fn set_current_span(&mut self, start: usize, end: usize) {
+        self.current_span = (start, end);
+    }
+
+    /// Get the current span
+    pub fn get_current_span(&self) -> (usize, usize) {
+        self.current_span
+    }
+
+    /// Set the source file information for span tracking and diagnostics
+    pub fn set_source(&mut self, file_name: String, content: String) {
+        self.inner.set_source(file_name, content);
+    }
+
     /// Store an expression and return its handle
     fn store_expr(&mut self, expr: TypedNode<TypedExpression>) -> NodeHandle {
         let handle = self.alloc_handle();
@@ -1229,20 +1252,30 @@ impl TypedAstBuilder {
         }
     }
 
-    /// Get the default span for nodes
+    /// Get the default span for nodes (uses current span from parsing)
     fn default_span(&self) -> Span {
-        self.inner.dummy_span()
+        Span::new(self.current_span.0, self.current_span.1)
     }
 
     /// Build and return the final TypedProgram
     pub fn build_program(&self) -> TypedProgram {
+        use zyntax_typed_ast::source::SourceFile;
+
         let decls: Vec<TypedNode<TypedDeclaration>> = self.program_decls.iter()
             .filter_map(|h| self.declarations.get(h).cloned())
             .collect();
 
+        // Create SourceFile if we have source information
+        let source_files = if let (Some(name), Some(content)) = (self.inner.source_file(), self.inner.source_content()) {
+            vec![SourceFile::new(name.to_string(), content.to_string())]
+        } else {
+            vec![]
+        };
+
         TypedProgram {
             declarations: decls,
             span: self.default_span(),
+            source_files,
         }
     }
 
@@ -1306,6 +1339,10 @@ impl AstHostFunctions for TypedAstBuilder {
             .unwrap_or_else(|e| format!(r#"{{"declarations": [], "error": "{}"}}"#, e))
     }
 
+    fn set_current_span(&mut self, start: usize, end: usize) {
+        self.current_span = (start, end);
+    }
+
     fn alloc_handle(&mut self) -> NodeHandle {
         let handle = NodeHandle(self.next_id);
         self.next_id += 1;
@@ -1487,6 +1524,7 @@ impl AstHostFunctions for TypedAstBuilder {
         items: Vec<NodeHandle>,
     ) -> NodeHandle {
         let span = self.default_span();
+        eprintln!("DEBUG: create_impl_block span=({}, {})", span.start, span.end);
 
         // Convert trait type arguments from handles to Type
         let trait_type_args: Vec<Type> = trait_args.iter()
@@ -2899,6 +2937,8 @@ pub struct CommandInterpreter<'a, H: AstHostFunctions> {
     value_stack: Vec<RuntimeValue>,
     /// Named variables
     variables: HashMap<String, RuntimeValue>,
+    /// Current span being processed (start, end)
+    current_span: (usize, usize),
 }
 
 impl<'a, H: AstHostFunctions> CommandInterpreter<'a, H> {
@@ -2909,9 +2949,20 @@ impl<'a, H: AstHostFunctions> CommandInterpreter<'a, H> {
             host,
             value_stack: Vec::new(),
             variables: HashMap::new(),
+            current_span: (0, 0),
         }
     }
 
+    /// Set the current span for the node being processed
+    pub fn set_current_span(&mut self, start: usize, end: usize) {
+        self.current_span = (start, end);
+    }
+
+    /// Get the current span
+    pub fn get_current_span(&self) -> (usize, usize) {
+        self.current_span
+    }
+
     /// Unescape a string literal, processing escape sequences
     fn unescape_string(s: &str) -> String {
         let mut result = String::with_capacity(s.len());

crates/zynml/src/lib.rs

@@ -256,10 +256,24 @@ impl ZynML {
 
     /// Run a ZynML program from a file
     pub fn run_file(&mut self, path: &Path) -> Result<()> {
-        let source = std::fs::read_to_string(path)
-            .with_context(|| format!("Failed to read file: {}", path.display()))?;
+        // Load the file with proper filename tracking for diagnostics
+        let functions = self.runtime
+            .load_module_file(path)
+            .with_context(|| format!("Failed to load file: {}", path.display()))?;
+
+        if self.config.verbose {
+            println!("Loaded {} functions", functions.len());
+        }
 
-        self.run(&source)
+        // Try to call main() if it exists
+        if functions.iter().any(|f| f == "main") {
+            if self.config.verbose {
+                println!("Calling main()...");
+            }
+            self.call("main")
+        } else {
+            Ok(()) // No main function to run
+        }
     }
 
     /// Get reference to the underlying runtime