Merge pull request #725 from wado-lang/claude/add-module-scope-attrs-L7XOk

Add #![TODO] and #![generated] module-scope attributes

Author: gfx

docs/cheatsheet.md

@@ -1121,6 +1121,8 @@ Paths in `#include_str` and `#include_bytes` are resolved relative to the source
 
 ```wado
 #![no_prelude]             // disable auto-import of core:prelude
+#![TODO]                   // all tests must fail; compile errors also accepted
+#![generated]              // marks machine-generated code (wado-from-wit, gale)
 
 struct Foo {
     #[hidden]

docs/spec.md

@@ -4393,6 +4393,27 @@ Module-level inner attribute. Prevents the automatic import of `core:prelude`. U
 // This module does not import core:prelude
 ```
 
+#### `#![TODO]`
+
+Module-level inner attribute. Marks the entire module as TODO for `wado test`. The source must parse successfully (otherwise the attribute cannot be recognized), but compilation errors are tolerated. If compilation fails, the module is reported as a passing TODO test. If compilation succeeds, all test blocks are treated as `#[TODO]` tests: they must fail (trap or error). If any test passes, it becomes a test failure, signaling that the `#![TODO]` attribute should be removed.
+
+```wado
+#![TODO]
+
+test "not yet implemented" {
+    panic("TODO");
+}
+```
+
+#### `#![generated]`
+
+Module-level inner attribute. Indicates that the module contains machine-generated code (e.g. from `wado-from-wit` or `gale`). Stored in the AST but not carried into TIR or later compilation stages. Reserved for future tooling use: language services may prohibit editing generated modules, and coverage tools may exclude them.
+
+```wado
+#![generated]
+// This file was generated by wado-from-wit — do not edit manually.
+```
+
 #### `#![wasm_module("name")]`
 
 Module-level inner attribute. All items in this module are compiled into a **separate Wasm core module** with the given name, rather than into the main GC core module.

package-gale/src/generator.wado

@@ -20,6 +20,7 @@ pub fn generate(grammar: &Grammar) -> String {
 }
 
 fn gen_header(w: &mut CodeWriter, name: &String) {
+    w.line("#![generated]");
     w.line(`// Generated by Gale from {name}.g4 — do not edit.`);
     w.blank();
 }

package-gale/src/generator_test.wado

@@ -19,7 +19,7 @@ test "generate header" {
     };
     let output = generate(&grammar);
     assert output.len() > 0;
-    let header = "// Generated by Gale from Test.g4";
+    let header = "#![generated]\n// Generated by Gale from Test.g4";
     for let mut i = 0; i < header.len(); i += 1 {
         assert output.get_byte(i) == header.get_byte(i);
     }

package-gale/tests/golden/calculator.wado

@@ -1,3 +1,4 @@
+#![generated]
 // Generated by Gale from calculator.g4 — do not edit.
 
 /// Span represents a byte range in source text.

package-gale/tests/golden/json.wado

@@ -1,3 +1,4 @@
+#![generated]
 // Generated by Gale from JSON.g4 — do not edit.
 
 /// Span represents a byte range in source text.

package-gale/tests/golden/sexpression.wado

@@ -1,3 +1,4 @@
+#![generated]
 // Generated by Gale from sexpression.g4 — do not edit.
 
 /// Span represents a byte range in source text.

package-gale/tests/golden/sqlite.wado

@@ -1,3 +1,4 @@
+#![generated]
 // Generated by Gale from SQLite.g4 — do not edit.
 
 /// Span represents a byte range in source text.

wado-cli/src/compile.rs

@@ -294,6 +294,50 @@ pub async fn compile_with_opts(
     .await
 }
 
+/// Try to compile a Wado source file, returning Result instead of exiting on error.
+/// Used by the test runner to gracefully handle compilation failures for `#![TODO]` modules.
+pub async fn try_compile_with_full_opts(
+    filename: &str,
+    opt_level: OptLevel,
+    log_level: LogLevel,
+    target_world: Option<String>,
+    skip_validation: bool,
+    inline_threshold: Option<usize>,
+    opt_iterations: Option<u32>,
+    allocator: Option<String>,
+) -> Result<wado_compiler::CompileResult, wado_compiler::CompileFailure> {
+    let path = Path::new(filename);
+
+    let source = match fs::read_to_string(path) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Error reading '{}': {e}", path.display());
+            return Err(wado_compiler::CompileFailure {
+                is_todo_module: false,
+            });
+        }
+    };
+
+    let base_path = path
+        .parent()
+        .map(std::path::Path::to_path_buf)
+        .unwrap_or_default();
+    let host = FilesystemCompilerHost::with_log_level(base_path, log_level);
+
+    let options = wado_compiler::CompilerOptions {
+        opt_level: to_compiler_opt_level(opt_level),
+        target_world,
+        skip_validation,
+        inline_threshold,
+        opt_iterations,
+        log_level: Some(log_level),
+        allocator,
+        ..Default::default()
+    };
+
+    wado_compiler::compile_with_options(&source, &host, Some(filename), options).await
+}
+
 /// Compile a Wado source file with full options including target world
 pub async fn compile_with_full_opts(
     filename: &str,

wado-cli/src/test.rs

@@ -266,19 +266,31 @@ fn extract_display_name(test_name: &str) -> String {
     }
 }
 
+/// A `#![TODO]` module that failed to compile.
+/// Treated as a passing result since the module is expected to have errors.
+struct TodoCompileError {
+    path: String,
+    compile_duration: Duration,
+}
+
 /// Phase 1: Compile all test files and collect test jobs
 async fn collect_test_jobs(
     paths: &[String],
     filter: Option<&str>,
-) -> Result<(Vec<Arc<CompiledTestModule>>, Vec<TestJob>)> {
+) -> Result<(
+    Vec<Arc<CompiledTestModule>>,
+    Vec<TestJob>,
+    Vec<TodoCompileError>,
+)> {
     let mut modules = Vec::new();
     let mut jobs = Vec::new();
+    let mut todo_compile_errors = Vec::new();
 
     for (module_idx, path) in paths.iter().enumerate() {
         // Compile with --world test so test functions become component exports
         // and non-test code is subject to DCE.
         let compile_start = Instant::now();
-        let wasm = compile::compile_with_full_opts(
+        let compile_result = compile::try_compile_with_full_opts(
             path,
             crate::compile::OptLevel::default(),
             wado_compiler::LogLevel::default(),
@@ -290,9 +302,26 @@ async fn collect_test_jobs(
         )
         .await;
         let compile_duration = compile_start.elapsed();
+
+        let compile_result = match compile_result {
+            Ok(result) => result,
+            Err(failure) if failure.is_todo_module => {
+                // #![TODO] module failed to compile — expected, count as pass
+                todo_compile_errors.push(TodoCompileError {
+                    path: path.clone(),
+                    compile_duration,
+                });
+                continue;
+            }
+            Err(_) => {
+                // Non-TODO module failed to compile — fatal
+                process::exit(1);
+            }
+        };
+
         let load_start = Instant::now();
         let engine = Arc::new(runtime::create_test_engine(wasmtime::OptLevel::None)?);
-        let component = Arc::new(Component::new(&engine, &wasm)?);
+        let component = Arc::new(Component::new(&engine, &compile_result.wasm)?);
         let load_duration = load_start.elapsed();
 
         // Find test functions from exports
@@ -334,7 +363,7 @@ async fn collect_test_jobs(
         }));
     }
 
-    Ok((modules, jobs))
+    Ok((modules, jobs, todo_compile_errors))
 }
 
 /// Run a single test in its own Store
@@ -545,15 +574,16 @@ pub async fn run(opts: TestOptions) {
     let overall_start = Instant::now();
 
     // Phase 1: Compile all files and collect test jobs
-    let (modules, jobs) = match collect_test_jobs(&opts.paths, opts.filter.as_deref()).await {
-        Ok(result) => result,
-        Err(e) => {
-            eprintln!("Error collecting tests: {e}");
-            process::exit(1);
-        }
-    };
+    let (modules, jobs, todo_compile_errors) =
+        match collect_test_jobs(&opts.paths, opts.filter.as_deref()).await {
+            Ok(result) => result,
+            Err(e) => {
+                eprintln!("Error collecting tests: {e}");
+                process::exit(1);
+            }
+        };
 
-    let total_tests = jobs.len();
+    let total_tests = jobs.len() + todo_compile_errors.len();
     if total_tests == 0 {
         println!("No tests found");
         return;
@@ -572,6 +602,12 @@ pub async fn run(opts: TestOptions) {
             .push(result);
     }
 
+    // Build lookup maps for display
+    let todo_error_by_path: indexmap::IndexMap<&str, &TodoCompileError> = todo_compile_errors
+        .iter()
+        .map(|e| (e.path.as_str(), e))
+        .collect();
+
     // Display results in file order (matching input order)
     let mut total_passed = 0;
     let mut total_failed = 0;
@@ -583,6 +619,15 @@ pub async fn run(opts: TestOptions) {
         .collect();
 
     for path in &opts.paths {
+        // Handle #![TODO] modules that failed to compile
+        if let Some(todo_err) = todo_error_by_path.get(path.as_str()) {
+            let compile = format_duration(todo_err.compile_duration);
+            println!("Running tests in {path}... (compile error, {compile})");
+            println!("  \x1b[32m✓\x1b[0m #![TODO] module — compile error (expected) ({compile})");
+            total_passed += 1;
+            continue;
+        }
+
         if let Some(file_results) = results_by_file.get(path) {
             let timing = module_by_path
                 .get(path.as_str())