//! Ruchy: A modern systems programming language

//!

//! Ruchy combines functional programming with systems programming capabilities,

//! featuring an ML-style syntax, advanced type inference, and zero-cost abstractions.

#![warn(clippy::all)]

// Temporarily disabled pedantic for RUCHY-0801 - Re-enable in quality sprint

// #![warn(clippy::pedantic)]

#![allow(clippy::module_name_repetitions)]

#![allow(clippy::must_use_candidate)]

// Clippy allows for RUCHY-0801 commit - will be addressed in quality sprint

#![allow(clippy::case_sensitive_file_extension_comparisons)]

#![allow(clippy::match_same_arms)]

#![allow(clippy::struct_excessive_bools)]

#![allow(clippy::cast_precision_loss)]

#![allow(clippy::cast_possible_truncation)]

#![allow(clippy::unused_self)]

#![allow(clippy::expect_used)]

#![allow(clippy::missing_errors_doc)]

#![allow(clippy::missing_panics_doc)]

// Additional clippy allows for P0 lint fixes  

#![allow(clippy::empty_line_after_doc_comments)]

#![allow(clippy::manual_let_else)]

#![allow(clippy::redundant_pattern_matching)]

#![allow(clippy::items_after_statements)]

#![allow(clippy::too_many_lines)]

#![allow(clippy::type_complexity)]

#![allow(dead_code)]

#![allow(clippy::float_cmp)]

#![allow(clippy::collapsible_match)]  

#![allow(clippy::cast_sign_loss)]

#![allow(clippy::manual_strip)]

#![allow(clippy::implicit_hasher)]

#![allow(clippy::too_many_arguments)]

#![allow(clippy::trivially_copy_pass_by_ref)]

#![allow(clippy::unnecessary_wraps)]

#![allow(clippy::only_used_in_recursion)]

#![allow(clippy::print_stdout)]

#![allow(clippy::print_stderr)]

#![allow(clippy::format_push_string)]

#![allow(clippy::field_reassign_with_default)]

#![allow(clippy::return_self_not_must_use)]

#![allow(clippy::unwrap_used)]

#![allow(clippy::needless_pass_by_value)]

#![allow(clippy::manual_clamp)]

#![allow(clippy::should_implement_trait)]

#![allow(clippy::unnecessary_to_owned)]

#![allow(clippy::cast_possible_wrap)]

#![allow(clippy::if_same_then_else)]

#[cfg(feature = "mcp")]

pub mod actors;

pub mod backend;

pub mod frontend;

pub mod lints;

#[cfg(feature = "mcp")]

pub mod lsp;

#[cfg(feature = "mcp")]

pub mod mcp;

pub mod middleend;

pub mod parser;

pub mod proving;

pub mod quality;

pub mod runtime;

#[cfg(any(test, feature = "testing"))]

pub mod testing;

#[cfg(any(test, feature = "testing"))]

pub use testing::AstBuilder;

pub mod transpiler;

pub mod wasm;

#[cfg(feature = "mcp")]

pub use actors::{

    Actor, ActorHandle, McpActor, McpMessage, McpResponse, SupervisionStrategy, Supervisor,

};

pub use backend::{ModuleResolver, Transpiler};

pub use frontend::ast::{BinaryOp, Expr, ExprKind, Literal, Pattern, UnaryOp};

pub use frontend::lexer::{Token, TokenStream};

pub use frontend::parser::Parser;

#[cfg(feature = "mcp")]

pub use lsp::{start_server, start_tcp_server, Formatter, RuchyLanguageServer, SemanticAnalyzer};

pub use quality::{

    CiQualityEnforcer, CoverageCollector, CoverageReport, CoverageTool, FileCoverage,

    HtmlReportGenerator, QualityGates, QualityMetrics, QualityReport, QualityThresholds,

};

pub use quality::gates::{QualityGateEnforcer, QualityGateConfig, GateResult};

use anyhow::Result;

/// Compile Ruchy source code to Rust

///

/// # Examples

///

/// ```

/// use ruchy::compile;

///

/// let rust_code = compile("42").expect("Failed to compile");

/// assert!(rust_code.contains("42"));

/// ```

///

/// # Errors

///

/// Returns an error if:

/// - The source code cannot be parsed

/// - The transpilation to Rust fails

pub fn compile(source: &str) -> Result<String> {

    let mut parser = Parser::new(source);

    let 
ast96
 = parser.parse()
?5
;

    let mut transpiler = Transpiler::new();

    // Use transpile_to_program to wrap in main() for standalone compilation

    let rust_code = transpiler.transpile_to_program(&ast)
?0
;

    Ok(rust_code.to_string())

}

/// Check if the given source code has valid syntax

#[must_use]

pub fn is_valid_syntax(source: &str) -> bool {

    let mut parser = Parser::new(source);

    parser.parse().is_ok()

}

/// Get parse error details if the source has syntax errors

#[must_use]

pub fn get_parse_error(source: &str) -> Option<String> {

    let mut parser = Parser::new(source);

    parser.parse().err().map(|e| 
e4
.
to_string4
())

}

/// Run the REPL

///

/// # Examples

///

/// ```no_run

/// use ruchy::run_repl;

///

/// run_repl().expect("Failed to run REPL");

/// ```

///

/// # Errors

///

/// Returns an error if:

/// - The REPL cannot be initialized

/// - User interaction fails

pub fn run_repl() -> Result<()> {

    let mut repl = runtime::repl::Repl::new()?;

    repl.run()

}

#[cfg(test)]

mod test_config {

    use std::sync::Once;

    static INIT: Once = Once::new();

    /// Initialize test configuration once per test run

    pub fn init() {

        INIT.call_once(|| {

            // Limit proptest for development (CI uses different settings)

            if std::env::var("CI").is_err() {

                std::env::set_var("PROPTEST_CASES", "10");

                std::env::set_var("PROPTEST_MAX_SHRINK_ITERS", "50");

            
}0

            // Limit test threads if not already set

            if std::env::var("RUST_TEST_THREADS").is_err() {

                std::env::set_var("RUST_TEST_THREADS", "4");

            }

        });

    }

}

#[cfg(test)]

#[allow(clippy::unwrap_used)]

#[allow(clippy::single_char_pattern)]

mod tests {

    use super::test_config;

    use super::*;

    #[test]

    fn test_compile_simple() {

        test_config::init();

        let result = compile("42").unwrap();

        assert!(result.contains("42"));

    }

    #[test]

    fn test_compile_let() {

        let result = compile("let x = 10 in x + 1").unwrap();

        assert!(result.contains("let"));

        assert!(result.contains("10"));

    }

    #[test]

    fn test_compile_function() {

        let result = compile("fun add(x: i32, y: i32) -> i32 { x + y }").unwrap();

        assert!(result.contains("fn"));

        assert!(result.contains("add"));

        assert!(result.contains("i32"));

    }

    #[test]

    fn test_compile_if() {

        let result = compile("if true { 1 } else { 0 }").unwrap();

        assert!(result.contains("if"));

        assert!(result.contains("else"));

    }

    #[test]

    fn test_compile_match() {

        let result = compile("match x { 0 => \"zero\", _ => \"other\" }").unwrap();

        assert!(result.contains("match"));

    }

    #[test]

    fn test_compile_list() {

        let result = compile("[1, 2, 3]").unwrap();

        assert!(result.contains("vec") && result.contains("!"));

    }

    #[test]

    fn test_compile_lambda() {

        let result = compile("|x| x * 2").unwrap();

        assert!(result.contains("|"));

    }

    #[test]

    fn test_compile_struct() {

        let result = compile("struct Point { x: f64, y: f64 }").unwrap();

        assert!(result.contains("struct"));

        assert!(result.contains("Point"));

    }

    #[test]

    fn test_compile_impl() {

        let result =

            compile("impl Point { fun new() -> Point { Point { x: 0.0, y: 0.0 } } }").unwrap();

        assert!(result.contains("impl"));

    }

    #[test]

    fn test_compile_trait() {

        let result = compile("trait Show { fun show(&self) -> String }").unwrap();

        assert!(result.contains("trait"));

    }

    #[test]

    fn test_compile_for_loop() {

        let result = compile("for x in [1, 2, 3] { print(x) }").unwrap();

        assert!(result.contains("for"));

    }

    #[test]

    fn test_compile_binary_ops() {

        let result = compile("1 + 2 * 3 - 4 / 2").unwrap();

        assert!(result.contains("+"));

        assert!(result.contains("*"));

        assert!(result.contains("-"));

        assert!(result.contains("/"));

    }

    #[test]

    fn test_compile_comparison_ops() {

        let result = compile("x < y && y <= z").unwrap();

        assert!(result.contains("<"));

        assert!(result.contains("<="));

        assert!(result.contains("&&"));

    }

    #[test]

    fn test_compile_unary_ops() {

        let result = compile("-x").unwrap();

        assert!(result.contains("-"));

        let result = compile("!flag").unwrap();

        assert!(result.contains("!"));

    }

    #[test]

    fn test_compile_call() {

        let result = compile("func(1, 2, 3)").unwrap();

        assert!(result.contains("func"));

        assert!(result.contains("("));

        assert!(result.contains(")"));

    }

    #[test]

    fn test_compile_method_call() {

        let result = compile("obj.method()").unwrap();

        assert!(result.contains("."));

        assert!(result.contains("method"));

    }

    #[test]

    fn test_compile_block() {

        let result = compile("{ let x = 1; x + 1 }").unwrap();

        assert!(result.contains("{"));

        assert!(result.contains("}"));

    }

    #[test]

    fn test_compile_string() {

        let result = compile("\"hello world\"").unwrap();

        assert!(result.contains("hello world"));

    }

    #[test]

    fn test_compile_bool() {

        let result = compile("true && false").unwrap();

        assert!(result.contains("true"));

        assert!(result.contains("false"));

    }

    #[test]

    fn test_compile_unit() {

        let result = compile("()").unwrap();

        assert!(result.contains("()"));

    }

    #[test]

    fn test_compile_nested_let() {

        let result = compile("let x = 1 in let y = 2 in x + y").unwrap();

        assert!(result.contains("let"));

    }

    #[test]

    fn test_compile_nested_if() {

        let result = compile("if x { if y { 1 } else { 2 } } else { 3 }").unwrap();

        assert!(result.contains("if"));

    }

    #[test]

    fn test_compile_empty_list() {

        let result = compile("[]").unwrap();

        assert!(result.contains("vec") && result.contains("!"));

    }

    #[test]

    fn test_compile_empty_block() {

        let result = compile("{ }").unwrap();

        assert!(result.contains("()"));

    }

    #[test]

    fn test_compile_float() {

        let result = compile("3.14159").unwrap();

        assert!(result.contains("3.14159"));

    }

    #[test]

    fn test_compile_large_int() {

        let result = compile("999999999").unwrap();

        assert!(result.contains("999999999"));

    }

    #[test]

    fn test_compile_string_escape() {

        let result = compile(r#""hello\nworld""#).unwrap();

        assert!(result.contains("hello"));

    }

    #[test]

    fn test_compile_power_op() {

        let result = compile("2 ** 8").unwrap();

        assert!(result.contains("pow"));

    }

    #[test]

    fn test_compile_modulo() {

        let result = compile("10 % 3").unwrap();

        assert!(result.contains("%"));

    }

    #[test]

    fn test_compile_bitwise_ops() {

        let result = compile("a & b | c ^ d").unwrap();

        assert!(result.contains("&"));

        assert!(result.contains("|"));

        assert!(result.contains("^"));

    }

    #[test]

    fn test_compile_left_shift() {

        let result = compile("x << 2").unwrap();

        assert!(result.contains("<<"));

    }

    #[test]

    fn test_compile_not_equal() {

        let result = compile("x != y").unwrap();

        assert!(result.contains("!="));

    }

    #[test]

    fn test_compile_greater_ops() {

        let result = compile("x > y && x >= z").unwrap();

        assert!(result.contains(">"));

        assert!(result.contains(">="));

    }

    #[test]

    fn test_compile_or_op() {

        let result = compile("x || y").unwrap();

        assert!(result.contains("||"));

    }

    #[test]

    fn test_compile_complex_expression() {

        let result = compile("(x + y) * (z - w) / 2").unwrap();

        assert!(result.contains("+"));

        assert!(result.contains("-"));

        assert!(result.contains("*"));

        assert!(result.contains("/"));

    }

    #[test]

    fn test_compile_errors() {

        assert!(compile("").is_err());

        assert!(compile("   ").is_err());

        assert!(compile("let x =").is_err());

        assert!(compile("if").is_err());

        assert!(compile("match").is_err());

    }

    #[test]

    fn test_is_valid_syntax_valid_cases() {

        assert!(is_valid_syntax("42"));

        assert!(is_valid_syntax("3.14"));

        assert!(is_valid_syntax("true"));

        assert!(is_valid_syntax("false"));

        assert!(is_valid_syntax("\"hello\""));

        assert!(is_valid_syntax("x + y"));

        assert!(is_valid_syntax("[1, 2, 3]"));

        assert!(is_valid_syntax("if true { 1 } else { 2 }"));

    }

    #[test]

    fn test_is_valid_syntax_invalid_cases() {

        assert!(!is_valid_syntax(""));

        assert!(!is_valid_syntax("   "));

        assert!(!is_valid_syntax("let x ="));

        assert!(!is_valid_syntax("if { }"));

        assert!(!is_valid_syntax("[1, 2,"));

        assert!(!is_valid_syntax("match"));

        assert!(!is_valid_syntax("struct"));

    }

    #[test]

    fn test_get_parse_error_with_errors() {

        let error = get_parse_error("fun (");

        assert!(error.is_some());

        // Error message format may vary, just check that we got an error

        assert!(!error.unwrap().is_empty());

    }

    #[test]

    fn test_get_parse_error_without_errors() {

        let error = get_parse_error("42");

        assert!(error.is_none());

    }

    #[test]

    fn test_get_parse_error_detailed() {

        let error = get_parse_error("if");

        assert!(error.is_some());

        let error = get_parse_error("match");

        assert!(error.is_some());

        let error = get_parse_error("[1, 2,");

        assert!(error.is_some());

    }

    #[test]

    fn test_compile_generic_function() {

        let result = compile("fun id<T>(x: T) -> T { x }").unwrap();

        assert!(result.contains("fn"));

        assert!(result.contains("id"));

    }

    #[test]

    fn test_compile_generic_struct() {

        let result = compile("struct Box<T> { value: T }").unwrap();

        assert!(result.contains("struct"));

        assert!(result.contains("Box"));

    }

    #[test]

    fn test_compile_multiple_statements() {

        let result = compile("let x = 1 in let y = 2 in x + y").unwrap();

        assert!(result.contains("let"));

    }

    #[test]

    fn test_compile_pattern_matching() {

        let result = compile("match x { 0 => \"zero\", _ => \"other\" }").unwrap();

        assert!(result.contains("match"));

    }

    #[test]

    fn test_compile_struct_literal() {

        let result = compile("Point { x: 10, y: 20 }").unwrap();

        assert!(result.contains("Point"));

    }

    // Test removed - try/catch operations removed in RUCHY-0834

    // #[test]

    // fn test_compile_try_operator() {

    //     let result = compile("func()?").unwrap();

    //     assert!(result.contains("?"));

    // }

    #[test]

    fn test_compile_await_expression() {

        let result = compile("async_func().await").unwrap();

        assert!(result.contains("await"));

    }

    #[test]

    fn test_compile_import() {

        let result = compile("import std.collections.HashMap").unwrap();

        assert!(result.contains("use"));

    }

    #[test]

    fn test_compile_while_loop() {

        let result = compile("while x < 10 { x + 1 }").unwrap();

        assert!(result.contains("while"));

    }

    #[test]

    fn test_compile_range() {

        let result = compile("1..10").unwrap();

        assert!(result.contains(".."));

    }

    #[test]

    fn test_compile_pipeline() {

        let result = compile("data |> filter |> map").unwrap();

        assert!(result.contains("("));

    }

    #[test]

    fn test_compile_send_operation() {

        let result = compile("myactor <- message").unwrap();

        assert!(result.contains(". send (")); // Formatted with spaces

        assert!(result.contains(". await")); // Formatted with spaces

    }

    #[test]

    fn test_compile_ask_operation() {

        let result = compile("myactor <? request").unwrap();

        assert!(result.contains(". ask (")); // Formatted with spaces

        assert!(result.contains(". await")); // Formatted with spaces

    }

    #[test]

    fn test_compile_list_comprehension() {

        let result = compile("[x * 2 for x in range(10)]").unwrap();

        assert!(result.contains("map"));

    }

    #[test]

    fn test_compile_actor() {

        let result = compile(

            r"

            actor Counter {

                count: i32,

                receive {

                    Inc => 1,

                    Get => 0

                }

            }

        ",

        )

        .unwrap();

        assert!(result.contains("struct Counter"));

        assert!(result.contains("enum CounterMessage"));

    }

    // ===== COMPREHENSIVE COVERAGE TESTS =====

    #[test]

    fn test_type_conversions() {

        // String conversions

        assert!(compile("str(42)").is_ok());

        assert!(compile("str(3.14)").is_ok());

        assert!(compile("str(true)").is_ok());

        // Integer conversions  

        assert!(compile("int(\"42\")").is_ok());

        assert!(compile("int(3.14)").is_ok());

        assert!(compile("int(true)").is_ok());

        // Float conversions

        assert!(compile("float(\"3.14\")").is_ok());

        assert!(compile("float(42)").is_ok());

        // Bool conversions

        assert!(compile("bool(0)").is_ok());

        assert!(compile("bool(\"\")").is_ok());

        assert!(compile("bool([])").is_ok());

        // Collection conversions

        assert!(compile("list(\"hello\")").is_ok());

        assert!(compile("set([1,2,3])").is_ok());

        assert!(compile("dict([(\"a\",1)])").is_ok());

    }

    #[test]

    fn test_method_calls() {

        // String methods

        assert!(compile("\"hello\".upper()").is_ok());

        assert!(compile("\"HELLO\".lower()").is_ok());

        assert!(compile("\"  hello  \".strip()").is_ok());

        assert!(compile("\"hello\".len()").is_ok());

        assert!(compile("\"hello\".split(\" \")").is_ok());

        // List methods

        assert!(compile("[1,2,3].len()").is_ok());

        assert!(compile("[1,2,3].append(4)").is_ok());

        assert!(compile("[1,2,3].pop()").is_ok());

        assert!(compile("[1,2,3].reverse()").is_ok());

        assert!(compile("[1,2,3].sort()").is_ok());

        // Dict methods

        assert!(compile("{\"a\":1}.get(\"a\")").is_ok());

        assert!(compile("{\"a\":1}.keys()").is_ok());

        assert!(compile("{\"a\":1}.values()").is_ok());

        assert!(compile("{\"a\":1}.items()").is_ok());

        // Iterator methods

        assert!(compile("[1,2,3].map(|x| x*2)").is_ok());

        assert!(compile("[1,2,3].filter(|x| x>1)").is_ok());

        assert!(compile("[1,2,3].reduce(|a,b| a+b)").is_ok());

    }

    #[test]

    #[ignore = "Patterns not fully implemented"]

    fn test_patterns() {

        // Literal patterns

        assert!(compile("match x { 0 => \"zero\", _ => \"other\" }").is_ok());

        assert!(compile("match x { true => \"yes\", false => \"no\" }").is_ok());

        // Tuple patterns

        assert!(compile("match p { (0, 0) => \"origin\", _ => \"other\" }").is_ok());

        assert!(compile("match p { (x, y) => x + y }").is_ok());

        // List patterns

        assert!(compile("match lst { [] => \"empty\", _ => \"has items\" }").is_ok());

        assert!(compile("match lst { [x] => x, _ => 0 }").is_ok());

        assert!(compile("match lst { [head, ...tail] => head, _ => 0 }").is_ok());

        // Struct patterns

        assert!(compile("match p { Point { x, y } => x + y }").is_ok());

        // Enum patterns

        assert!(compile("match opt { Some(x) => x, None => 0 }").is_ok());

        assert!(compile("match res { Ok(v) => v, Err(e) => panic(e) }").is_ok());

        // Guard patterns

        assert!(compile("match x { n if n > 0 => \"positive\", _ => \"other\" }").is_ok());

        // Or patterns

        assert!(compile("match x { 0 | 1 => \"binary\", _ => \"other\" }").is_ok());

    }

    #[test]

    #[ignore = "Not all operators implemented yet"]

    fn test_all_operators() {

        // Arithmetic

        assert!(compile("x + y").is_ok());

        assert!(compile("x - y").is_ok());

        assert!(compile("x * y").is_ok());

        assert!(compile("x / y").is_ok());

        assert!(compile("x % y").is_ok());

        assert!(compile("x ** y").is_ok());

        // Comparison

        assert!(compile("x == y").is_ok());

        assert!(compile("x != y").is_ok());

        assert!(compile("x < y").is_ok());

        assert!(compile("x > y").is_ok());

        assert!(compile("x <= y").is_ok());

        assert!(compile("x >= y").is_ok());

        // Logical

        assert!(compile("x && y").is_ok());

        assert!(compile("x || y").is_ok());

        assert!(compile("!x").is_ok());

        // Bitwise

        assert!(compile("x & y").is_ok());

        assert!(compile("x | y").is_ok());

        assert!(compile("x ^ y").is_ok());

        assert!(compile("~x").is_ok());

        assert!(compile("x << y").is_ok());

        assert!(compile("x >> y").is_ok());

        // Assignment

        assert!(compile("x = 5").is_ok());

        assert!(compile("x += 5").is_ok());

        assert!(compile("x -= 5").is_ok());

        assert!(compile("x *= 5").is_ok());

        assert!(compile("x /= 5").is_ok());

        // Special

        assert!(compile("x ?? y").is_ok());

        assert!(compile("x?.y").is_ok());

    }

    #[test]

    #[ignore = "Control flow not fully implemented"]

    fn test_control_flow() {

        // If statements

        assert!(compile("if x { 1 }").is_ok());

        assert!(compile("if x { 1 } else { 2 }").is_ok());

        assert!(compile("if x { 1 } else if y { 2 } else { 3 }").is_ok());

        // Loops

        assert!(compile("while x { y }").is_ok());

        assert!(compile("loop { break }").is_ok());

        assert!(compile("for i in 0..10 { }").is_ok());

        assert!(compile("for i in items { }").is_ok());

        // Break/continue

        assert!(compile("while true { break }").is_ok());

        assert!(compile("for i in 0..10 { continue }").is_ok());

    }

    #[test]

    #[ignore = "Data structures not fully implemented"]

    fn test_data_structures() {

        // Lists

        assert!(compile("[]").is_ok());

        assert!(compile("[1, 2, 3]").is_ok());

        assert!(compile("[[1, 2], [3, 4]]").is_ok());

        // Dicts

        assert!(compile("{}").is_ok());

        assert!(compile("{\"a\": 1}").is_ok());

        assert!(compile("{\"a\": 1, \"b\": 2}").is_ok());

        // Sets

        assert!(compile("{1}").is_ok());

        assert!(compile("{1, 2, 3}").is_ok());

        // Tuples

        assert!(compile("()").is_ok());

        assert!(compile("(1,)").is_ok());

        assert!(compile("(1, 2, 3)").is_ok());

    }

    #[test]

    #[ignore = "Functions not fully implemented"]

    fn test_functions_lambdas() {

        // Functions

        assert!(compile("fn f() { }").is_ok());

        assert!(compile("fn f(x) { x }").is_ok());

        assert!(compile("fn f(x, y) { x + y }").is_ok());

        assert!(compile("fn f(x: int) -> int { x }").is_ok());

        // Lambdas

        assert!(compile("|x| x").is_ok());

        assert!(compile("|x, y| x + y").is_ok());

        assert!(compile("|| 42").is_ok());

        // Async

        assert!(compile("async fn f() { await g() }").is_ok());

        assert!(compile("await fetch(url)").is_ok());

    }

    #[test]

    fn test_string_interpolation() {

        assert!(compile("f\"Hello {name}\"").is_ok());

        assert!(compile("f\"x = {x}, y = {y}\"").is_ok());

        assert!(compile("f\"Result: {calculate()}\"").is_ok());

    }

    #[test]

    #[ignore = "Comprehensions not fully implemented"]

    fn test_comprehensions() {

        assert!(compile("[x * 2 for x in 0..10]").is_ok());

        assert!(compile("[x for x in items if x > 0]").is_ok());

        assert!(compile("{x: x*x for x in 0..5}").is_ok());

        assert!(compile("{x for x in items if unique(x)}").is_ok());

    }

    #[test]

    #[ignore = "Destructuring not fully implemented"]

    fn test_destructuring() {

        assert!(compile("let [a, b, c] = [1, 2, 3]").is_ok());

        assert!(compile("let {x, y} = point").is_ok());

        assert!(compile("let [head, ...tail] = list").is_ok());

        assert!(compile("let (a, b) = (1, 2)").is_ok());

    }

    #[test]

    #[ignore = "Error handling not fully implemented"]

    fn test_error_handling() {

        assert!(compile("try { risky() } catch e { handle(e) }").is_ok());

        assert!(compile("result?").is_ok());

        assert!(compile("result.unwrap()").is_ok());

        assert!(compile("result.expect(\"failed\")").is_ok());

        assert!(compile("result.unwrap_or(default)").is_ok());

    }

    #[test]

    #[ignore = "Classes/structs not fully implemented"]

    fn test_classes_structs() {

        assert!(compile("struct Point { x: int, y: int }").is_ok());

        assert!(compile("class Calculator { fn add(x, y) { x + y } }").is_ok());

        assert!(compile("enum Option { Some(value), None }").is_ok());

    }

    #[test]

    #[ignore = "Imports not fully implemented"]

    fn test_imports() {

        assert!(compile("import std").is_ok());

        assert!(compile("from std import println").is_ok());

        assert!(compile("import { readFile, writeFile } from fs").is_ok());

        assert!(compile("export fn helper()").is_ok());

    }

    #[test]

    fn test_decorators() {

        assert!(compile("@memoize\nfn expensive(n) { }").is_ok());

        assert!(compile("@derive(Debug, Clone)\nstruct Data { }").is_ok());

    }

    #[test]

    fn test_generics() {

        assert!(compile("fn identity<T>(x: T) -> T { x }").is_ok());

        assert!(compile("struct Pair<T, U> { first: T, second: U }").is_ok());

        assert!(compile("enum Result<T, E> { Ok(T), Err(E) }").is_ok());

    }

    #[test]

    fn test_edge_cases() {

        // Empty input - parser expects at least one expression

        assert!(!is_valid_syntax(""));

        assert!(!is_valid_syntax("   "));

        assert!(!is_valid_syntax("\n\n"));

        // Deeply nested

        assert!(compile("((((((((((1))))))))))").is_ok());

        assert!(compile("[[[[[[1]]]]]]").is_ok());

        // Unicode

        assert!(compile("\"Hello 世界\"").is_ok());

        assert!(compile("\"Emoji 😀\"").is_ok());

    }

    #[test]

    fn test_complex_programs() {

        let factorial = r#"

            fn factorial(n) {

                if n <= 1 { 1 } else { n * factorial(n-1) }

            }

        "#;

        assert!(compile(factorial).is_ok());

        let fibonacci = r#"

            fn fibonacci(n) {

                match n {

                    0 => 0,

                    1 => 1,

                    _ => fibonacci(n-1) + fibonacci(n-2)

                }

            }

        "#;

        assert!(compile(fibonacci).is_ok());

        let quicksort = r#"

            fn quicksort(arr) {

                if arr.len() <= 1 { 

                    arr 

                } else {

                    let pivot = arr[0]

                    let less = [x for x in arr[1:] if x < pivot]

                    let greater = [x for x in arr[1:] if x >= pivot]

                    quicksort(less) + [pivot] + quicksort(greater)

                }

            }

        "#;

        assert!(compile(quicksort).is_ok());

    }

}