test type checking

Author: lucarlig

src/error.rs

@@ -152,6 +152,13 @@ pub enum CompileError {
         help("This is an internal compiler error. Please report it as a bug")
     )]
     Codegen(#[from] CodegenErrorData),
+
+    #[error(transparent)]
+    #[diagnostic(
+        code(descend::missing_main_error),
+        help("A main function is required as the entry point of your program")
+    )]
+    MissingMain(#[from] MissingMainErrorData),
 }
 
 /// Data for FileIO errors with miette diagnostic support
@@ -221,6 +228,18 @@ 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 {
@@ -486,12 +505,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/main.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();
@@ -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(())

tests/error_examples.rs

@@ -2,57 +2,36 @@
 // 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),
-    }
+    test_error_compilation(
+        "examples/error-examples/nonexistent_file.desc",
+        |err| matches!(err, CompileError::FileIO(_)),
+        "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;
-
-    // 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();
+fn missing_main_error() {
+    // Test compilation of a file without a main function which should fail with a MissingMain error
+    test_error_compilation(
+        "examples/error-examples/missing_main.desc",
+        |err| matches!(err, CompileError::MissingMain(_)),
+        "MissingMain",
+    );
+}
 
-    // 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<F>(file_path: &str, error_checker: F, error_name: &str)
+where
+    F: FnOnce(&CompileError) -> bool,
+{
+    // Test compilation of a file which should fail with the expected error
+    let err = descend::compile(file_path).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
+    let miette_report = miette::Report::new(err.clone());
 
     // Use the graphical handler to get fancy output
     let handler = miette::GraphicalReportHandler::new();
@@ -61,5 +40,12 @@ fn test_missing_main_error() {
         .render_report(&mut output, miette_report.as_ref())
         .unwrap();
 
-    insta::assert_snapshot!(output);
+    insta::assert_snapshot!(error_name, output);
+
+    assert!(
+        error_checker(&err),
+        "Expected {} error, got {:?}",
+        error_name,
+        err
+    );
 }

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

@@ -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