test type checking

Author: lucarlig

examples/error-examples/fileio_error.desc renamed to examples/error-examples/parse_error.desc

@@ -21,8 +21,10 @@ fn npu_vec_add<r: prv, n: nat>(
 ) -[grid: npu.grid<X<64>, X<1024>>]-> () {
     sched block in grid {
         sched thread in block {
-            let a_ref = &uniq (*a_array).to_view.grp::<1024>[[block]][[thread + offset]];
-            *a_ref = *a_ref + (*b_array).to_view.grp::<1024>[[block]][[thread + offset]]
+            let a = thread + offset;
+            let b = thread + offset;
+            let a_ref = &uniq (*a_array).to_view.grp::<1024>[[block]][[a]];
+            *a_ref = *a_ref + (*b_array).to_view.grp::<1024>[[block]][[b]]
         }
     }
 }

examples/error-examples/thread_idx_offset.desc renamed to examples/error-examples/thread_idx_offset.desc.off

@@ -123,35 +123,22 @@ pub fn with_related(report: miette::Report, _related_text: &str) -> miette::Repo
 }
 
 /// Enum representing different types of compilation errors
-#[derive(Error, Diagnostic, Debug, Clone)]
+#[derive(Error, Debug, Clone)]
 pub enum CompileError {
     #[error(transparent)]
-    #[diagnostic(
-        code(descend::file_io_error),
-        help("Check that the file exists and you have permission to read it")
-    )]
     FileIO(#[from] FileIOErrorData),
 
-    #[error(transparent)]
-    #[diagnostic(
-        code(descend::parse_error),
-        help("Check the syntax of your Descend code")
-    )]
-    Parse(#[from] ParseErrorData),
+    #[error("{0}")]
+    Parse(ParseErrorData),
 
     #[error(transparent)]
-    #[diagnostic(
-        code(descend::type_check_error),
-        help("Check your type annotations and variable usage")
-    )]
     TypeCheck(#[from] TypeCheckErrorData),
 
     #[error(transparent)]
-    #[diagnostic(
-        code(descend::codegen_error),
-        help("This is an internal compiler error. Please report it as a bug")
-    )]
     Codegen(#[from] CodegenErrorData),
+
+    #[error(transparent)]
+    MissingMain(#[from] MissingMainErrorData),
 }
 
 /// Data for FileIO errors with miette diagnostic support
@@ -181,7 +168,7 @@ pub struct ParseErrorData {
     pub message: String,
 
     #[label("Parse error location")]
-    pub span: Option<SourceSpan>,
+    pub span: SourceSpan,
 }
 
 /// Data for TypeCheck errors with miette diagnostic support
@@ -221,15 +208,63 @@ pub struct CodegenErrorData {
     pub span: Option<SourceSpan>,
 }
 
+/// Data for MissingMain errors with miette diagnostic support
+#[derive(Error, Diagnostic, Debug, Clone)]
+#[error("Missing main function")]
+#[diagnostic(
+    code(descend::missing_main_error),
+    help("A main function is required as the entry point of your program")
+)]
+pub struct MissingMainErrorData {
+    pub message: String,
+    pub help_text: Option<String>,
+}
+
 impl CompileError {
     /// Attach source code to the error for beautiful display
     pub fn with_source_code(self, source: miette::NamedSource<String>) -> miette::Report {
         miette::Report::new(self).with_source_code(source)
     }
 }
 
+impl Diagnostic for CompileError {
+    fn code<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        match self {
+            CompileError::Parse(_) => Some(Box::new("descend::parse_error")),
+            CompileError::FileIO(_) => Some(Box::new("descend::file_io_error")),
+            CompileError::TypeCheck(_) => Some(Box::new("descend::type_check_error")),
+            CompileError::Codegen(_) => Some(Box::new("descend::codegen_error")),
+            CompileError::MissingMain(_) => Some(Box::new("descend::missing_main_error")),
+        }
+    }
+
+    fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        match self {
+            CompileError::Parse(_) => Some(Box::new("Check the syntax of your Descend code")),
+            CompileError::FileIO(_) => Some(Box::new("Check that the file exists and you have permission to read it")),
+            CompileError::TypeCheck(_) => Some(Box::new("Check your type annotations and variable usage")),
+            CompileError::Codegen(_) => Some(Box::new("This is an internal compiler error. Please report it as a bug")),
+            CompileError::MissingMain(_) => Some(Box::new("A main function is required as the entry point of your program")),
+        }
+    }
+
+    fn labels<'a>(&'a self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + 'a>> {
+        match self {
+            CompileError::Parse(parse_err) => {
+                let start: usize = parse_err.span.offset().into();
+                let end = start + parse_err.span.len();
+                Some(Box::new(std::iter::once(LabeledSpan::new_with_span(
+                    Some("Parse error location".to_string()),
+                    start..end,
+                ))))
+            }
+            _ => None,
+        }
+    }
+}
+
 /// Convert ErrorKind to human-readable message
-fn error_kind_to_message(kind: std::io::ErrorKind) -> String {
+pub fn error_kind_to_message(kind: std::io::ErrorKind) -> String {
     match kind {
         std::io::ErrorKind::NotFound => "entity not found".to_string(),
         std::io::ErrorKind::PermissionDenied => "permission denied".to_string(),
@@ -239,17 +274,8 @@ fn error_kind_to_message(kind: std::io::ErrorKind) -> String {
     }
 }
 
-/// Convert std::io::Error to CompileError for easy error handling
-impl From<std::io::Error> for CompileError {
-    fn from(error: std::io::Error) -> Self {
-        CompileError::FileIO(FileIOErrorData {
-            file_path: "unknown file".to_string(),
-            io_error_kind: error.kind(),
-            error_message: error_kind_to_message(error.kind()),
-            span: None,
-        })
-    }
-}
+// Note: std::io::Error should be converted through SourceCode::from_file
+// to preserve the file path information
 
 /// Convert TyError to CompileError with span preservation
 impl From<crate::ty_check::error::TyError> for CompileError {
@@ -486,12 +512,9 @@ impl From<crate::ty_check::error::TyError> for CompileError {
                 }
             }
             TyError::MissingMain => {
-                CompileError::TypeCheck(TypeCheckErrorData {
+                CompileError::MissingMain(MissingMainErrorData {
                     message: "Missing main function".to_string(),
-                    span: None,
-                    secondary_spans: vec![],
                     help_text: Some("A main function is required as the entry point of your program.".to_string()),
-                    related: None,
                 })
             }
             TyError::NatEvalError(nat_err, span) => {

src/error.rs

@@ -10,7 +10,11 @@ pub mod ty_check;
 
 pub fn compile(file_path: &str) -> Result<(String, String), CompileError> {
     let source = parser::SourceCode::from_file(file_path)?;
-    let mut compil_unit = parser::parse(&source)?;
+    compile_from_source(&source)
+}
+
+pub fn compile_from_source(source: &parser::SourceCode) -> Result<(String, String), CompileError> {
+    let mut compil_unit = parser::parse(source)?;
     ty_check::ty_check(&mut compil_unit)?;
 
     let code_string = codegen::mlir::gen_checked(&compil_unit, false).map_err(|e| {
@@ -24,3 +28,26 @@ pub fn compile(file_path: &str) -> Result<(String, String), CompileError> {
 
     Ok((code_string, ast_string))
 }
+
+/// Compile a file and return a miette::Report for errors (with source code attached)
+pub fn compile_with_source(file_path: &str) -> Result<(String, String), miette::Report> {
+    let source_code = std::fs::read_to_string(file_path).map_err(|e| {
+        use crate::error::{CompileError, FileIOErrorData};
+        CompileError::FileIO(FileIOErrorData {
+            file_path: file_path.to_string(),
+            io_error_kind: e.kind(),
+            error_message: crate::error::error_kind_to_message(e.kind()),
+            span: None,
+        })
+        .with_source_code(miette::NamedSource::new(file_path, String::new()))
+    })?;
+
+    let named_source = miette::NamedSource::new(file_path, source_code.clone());
+    let source = parser::SourceCode::from_file(file_path)
+        .map_err(|e| e.with_source_code(named_source.clone()))?;
+
+    match compile_from_source(&source) {
+        Ok(result) => Ok(result),
+        Err(err) => Err(err.with_source_code(named_source)),
+    }
+}

src/lib.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use descend;
-use descend::error::CompileError;
+use miette::IntoDiagnostic;
 use std::fs;
 use std::path::PathBuf;
 
@@ -20,7 +20,7 @@ struct Args {
     print_ast: bool,
 }
 
-fn main() -> Result<(), CompileError> {
+fn main() -> miette::Result<()> {
     miette::set_panic_hook();
 
     let args = Args::parse();
@@ -30,7 +30,7 @@ fn main() -> Result<(), CompileError> {
     let output_dir = &args.output_dir;
 
     // Compile using Descend
-    let (code_string, ast_string) = descend::compile(&input_path.to_string_lossy())?;
+    let (code_string, ast_string) = descend::compile_with_source(&input_path.to_string_lossy())?;
 
     // Generate output file path with appropriate extension
     let filename_stem = input_path.file_stem().unwrap_or_default().to_string_lossy();
@@ -40,11 +40,11 @@ fn main() -> Result<(), CompileError> {
     if print_ast {
         let ast_file = output_dir.join(format!("{}.ast", filename_stem));
         // Write result to file
-        fs::write(&ast_file, ast_string)?;
+        fs::write(&ast_file, ast_string).into_diagnostic()?;
         println!("AST file written successfully to: {}", ast_file.display());
     }
     // Write result to file
-    fs::write(&code_file, code_string)?;
+    fs::write(&code_file, code_string).into_diagnostic()?;
     println!("code file written successfully to: {}", code_file.display());
 
     Ok(())

src/main.rs

@@ -14,9 +14,13 @@ pub use source::*;
 pub fn parse<'a>(source: &'a SourceCode<'a>) -> Result<CompilUnit<'a>, CompileError> {
     let parser = Parser::new(source);
     let mut items = parser.parse().map_err(|err| {
+        let span = err.extract_span().unwrap_or_else(|| {
+            // Fallback to a default span if extraction fails
+            miette::SourceSpan::new(miette::SourceOffset::from(0), 1)
+        });
         CompileError::Parse(ParseErrorData {
             message: format!("Parse error: {}", err),
-            span: None, // TODO: Extract span from ParseError
+            span,
         })
     })?;
     // TODO refactor to not require unnecessary copying out of items
@@ -311,6 +315,26 @@ pub mod error {
             ParseError { parser, err }
         }
 
+        /// Extract the source span from the parse error
+        pub fn extract_span(&self) -> Option<miette::SourceSpan> {
+            let line_num = u32::try_from(self.err.location.line).ok()?;
+            let column_num = u32::try_from(self.err.location.column).ok()?;
+
+            // Convert from 1-based to 0-based line numbers
+            let line_num = line_num - 1;
+            // Convert from 1-based to 0-based column numbers
+            let column_num = column_num - 1;
+
+            // Get the byte offset for the error location
+            let start_offset = self.parser.source.get_offset(line_num, column_num);
+            let end_offset = start_offset + 1; // Single character span
+
+            Some(miette::SourceSpan::new(
+                miette::SourceOffset::from(start_offset),
+                end_offset - start_offset,
+            ))
+        }
+
         pub fn emit(&self) -> ErrorReported {
             let label = format!("expected {}", self.err.expected);
             let line_num =

src/parser/mod.rs

@@ -2,57 +2,33 @@
 // instead of using the macro which is designed for successful compilation tests
 
 use descend::error::CompileError;
-use std::io::ErrorKind;
 
 #[test]
-fn test_fileio_error() {
+fn fileio_error() {
     // Test compilation of a non-existent file which should fail with a FileIO error
-    let err = descend::compile("examples/error-examples/nonexistent_file.desc")
-        .err()
-        .unwrap();
-
-    // Also test the full miette diagnostic output
-    let miette_report = miette::Report::new(err.clone());
-
-    // Use the graphical handler to get fancy output
-    let handler = miette::GraphicalReportHandler::new();
-    let mut output = String::new();
-    handler
-        .render_report(&mut output, miette_report.as_ref())
-        .unwrap();
-
-    insta::assert_snapshot!(output);
-
-    // Assert that compilation failed with a FileIO error
-    match err {
-        CompileError::FileIO(data) => {
-            assert_eq!(
-                data.file_path,
-                "examples/error-examples/nonexistent_file.desc"
-            );
-            assert_eq!(data.io_error_kind, ErrorKind::NotFound);
-        }
-        _ => panic!("Expected FileIO error, got {:?}", err),
-    }
+    let err = test_error_compilation("examples/error-examples/nonexistent_file.desc");
+    assert!(matches!(err, CompileError::FileIO(_)));
 }
-
 #[test]
-fn test_missing_main_error() {
-    // Test the missing main error directly by calling the type checker
-    use descend::parser::SourceCode;
-    use descend::ty_check::error::TyError;
+fn missing_main_error() {
+    // Test compilation of a file without a main function which should fail with a MissingMain error
+    let err = test_error_compilation("examples/error-examples/missing_main.desc");
+    assert!(matches!(err, CompileError::MissingMain(_)));
+}
 
-    // Parse the file first
-    let source = SourceCode::from_file("examples/error-examples/missing_main.desc").unwrap();
-    let mut compil_unit = descend::parser::parse(&source).unwrap();
+#[test]
+fn parse_error() {
+    let err = test_error_compilation("examples/error-examples/parse_error.desc");
+    assert!(matches!(err, CompileError::Parse(_)));
+}
 
-    // Call type checker directly to get the actual MissingMain error
-    let result = descend::ty_check::ty_check(&mut compil_unit);
-    assert!(result.is_err()); // Should fail with MissingMain error
+fn test_error_compilation(file_path: &str) -> CompileError {
+    // Test compilation of a file which should fail with the expected error
+    let result = descend::compile(file_path);
+    let err: CompileError = result.err().unwrap();
 
-    // Test the actual MissingMain error diagnostic
-    let missing_main_error = TyError::MissingMain;
-    let miette_report = miette::Report::new(missing_main_error);
+    // Also test the full miette diagnostic output with source code
+    let miette_report = descend::compile_with_source(file_path).err().unwrap();
 
     // Use the graphical handler to get fancy output
     let handler = miette::GraphicalReportHandler::new();
@@ -61,5 +37,6 @@ fn test_missing_main_error() {
         .render_report(&mut output, miette_report.as_ref())
         .unwrap();
 
-    insta::assert_snapshot!(output);
+    insta::assert_snapshot!(file_path, output);
+    err
 }

tests/error_examples.rs

@@ -2,7 +2,7 @@
 source: tests/error_examples.rs
 expression: output
 ---
-[31mdescend::ty_check::missing_main[0m
+[31mdescend::missing_main_error[0m
 
-  [31m×[0m missing main function
-[36m  help: [0mA main function is required as the entry point of your program.
+  [31m×[0m Missing main function
+[36m  help: [0mA main function is required as the entry point of your program

tests/snapshots/error_examples__fileio_error.snap renamed to tests/snapshots/error_examples__FileIO.snap

@@ -0,0 +1,8 @@
+---
+source: tests/error_examples.rs
+expression: output
+---
+descend::missing_main_error
+
+  × Missing main function
+  help: A main function is required as the entry point of your program