feat: add support for line and block comments

Author: walker84837

examples/block_comments.kit

@@ -0,0 +1,13 @@
+include "stdio.h";
+
+/* Block comment at start of file */
+function main() {
+    /* Block comment with indentation */
+    var x: int = 42; /* End of line block comment */
+
+    /*
+     * Multi-line block comment
+     * with multiple lines
+     */
+    printf("%d", x);
+}

examples/block_comments.kit.expected

@@ -0,0 +1 @@
+42

examples/line_comments.kit

@@ -0,0 +1,10 @@
+include "stdio.h";
+
+// Line comment at start of file
+function main() {
+    // Line comment with indentation
+    var x: int = 42; // End of line comment
+
+    // Another line comment
+    printf("%d", x);
+}

examples/line_comments.kit.expected

@@ -0,0 +1 @@
+42

examples/mixed_comments.kit

@@ -0,0 +1,18 @@
+include "stdio.h";
+
+// Mix of line and block comments
+function main() {
+    // Start with line comment
+    var x: int = 1;
+
+    /* Block comment in middle */
+    var y: int = 2; // End of line comment
+
+    /*
+     * Multi-line block comment
+     * followed by line comment
+     */
+    // After multi-line
+    var z: int = x + y;
+    printf("%d", z); /* Block comment at end */
+}

examples/mixed_comments.kit.expected

@@ -0,0 +1 @@
+3

examples/nested_comments.kit

@@ -0,0 +1,8 @@
+include "stdio.h";
+
+// Test that nested block comments fail appropriately (this should not compile)
+function main() {
+    /* This has /* nested */ comment */
+    var x = 1;
+    printf("%d\n", x);
+}

kitc/tests/examples.rs

@@ -159,3 +159,47 @@ fn test_range_negative() -> Result<(), Box<dyn std::error::Error>> {
 fn test_simple_range() -> Result<(), Box<dyn std::error::Error>> {
     run_example_test("simple_range", None)
 }
+
+#[test]
+fn test_line_comments() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("line_comments", None)
+}
+
+#[test]
+fn test_block_comments() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("block_comments", None)
+}
+
+#[test]
+fn test_mixed_comments() -> Result<(), Box<dyn std::error::Error>> {
+    run_example_test("mixed_comments", None)
+}
+
+#[test]
+#[test]
+fn test_nested_comments() -> Result<(), Box<dyn std::error::Error>> {
+    let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or("couldn't get workspace root")?;
+
+    let examples_dir = workspace_root.join("examples");
+    let example_file = examples_dir.join("nested_comments.kit");
+
+    assert!(
+        example_file.exists(),
+        "example file {} does not exist",
+        example_file.display()
+    );
+
+    // This test should fail to compile due to nested block comments
+    let kitc = cargo_bin!("kitc");
+    let mut cmd = assert_cmd::Command::from_std(std::process::Command::new(kitc));
+    cmd.current_dir(workspace_root);
+    cmd.arg("compile").arg(&example_file);
+
+    let result = cmd.assert();
+    // Should fail to compile
+    assert!(result.try_success().is_err());
+
+    Ok(())
+}

kitlang/src/codegen/frontend.rs

@@ -5,10 +5,10 @@ use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use crate::codegen::ast::{Include, Program, Function, Block, Stmt, Expr, Literal};
+use crate::codegen::ast::*;
 use crate::codegen::compiler::{CompilerMeta, CompilerOptions, Toolchain};
-use crate::codegen::types::{Type, ToCRepr};
 use crate::codegen::parser::Parser as CodeParser;
+use crate::codegen::types::{ToCRepr, Type};
 
 pub type CompileResult<T> = Result<T, CompilationError>;
 
@@ -29,7 +29,7 @@ impl Compiler {
             c_output: output.as_ref().with_extension("c"),
             includes: Vec::new(),
             libs,
-            parser: CodeParser,
+            parser: CodeParser::new(),
         }
     }
 

kitlang/src/codegen/mod.rs

@@ -7,8 +7,8 @@
 pub mod ast;
 pub mod compiler;
 pub mod parser;
+pub use ast::{Block, Expr, Function, Include, Literal, Param, Program, Stmt};
 pub use compiler::Toolchain;
-pub use ast::{Include, Program, Function, Param, Block, Stmt, Expr, Literal};
 
 /// Handles the initial parsing of Kitlang source files, constructs the
 /// Abstract Syntax Tree (AST), and orchestrates the generation of C code