parser.rs

mod support;

use std::fs;
use std::path::{Path, PathBuf};

use insta::assert_snapshot;
use notplusplus::diag::DiagEngine;
use notplusplus::parse::{
    AssignOp, BinaryOp, Expr, ExprStmt, FunctionDef, Program, Stmt, TopLevelDecl, Type, parse,
    render_ast,
};
use notplusplus::source::SourceManager;

#[test]
fn parser_goldens_match() {
    let fixture_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/parser");
    let mut fixtures = fixture_paths(&fixture_dir);

    assert!(
        !fixtures.is_empty(),
        "expected parser fixtures in {}",
        fixture_dir.display()
    );

    fixtures.sort();

    for fixture in fixtures {
        let name = fixture
            .file_stem()
            .and_then(|stem| stem.to_str())
            .expect("fixture names should be valid UTF-8");
        let source = fs::read_to_string(&fixture)
            .unwrap_or_else(|err| panic!("failed to read fixture {}: {err}", fixture.display()));

        let mut sm = SourceManager::new();
        let file = sm.add_file(
            fixture
                .file_name()
                .and_then(|file_name| file_name.to_str())
                .expect("fixture file names should be valid UTF-8")
                .to_owned(),
            source,
        );
        let mut diags = DiagEngine::new();
        let program = parse(&sm, file, &mut diags);
        let rendered = render_snapshot(&sm, &program, &diags);

        assert_snapshot!(name, rendered);
    }
}

#[test]
fn parser_renders_ast_dump_for_cli_output() {
    let program = parse_source(
        "dump_ast.cpp",
        "int main() {\n    int value = 1;\n    return value;\n}\n",
    );

    assert_snapshot!("parser_render_ast_dump", render_ast(&program));
}

#[test]
fn parser_builds_expected_operator_associativity() {
    let program = parse_source(
        "associativity.cpp",
        "int main() {\n    a = b = c;\n    x - y - z;\n    p || q && r;\n    return 0;\n}\n",
    );

    let [TopLevelDecl::FunctionDef(FunctionDef { body, .. })] = &program.decls[..] else {
        panic!("expected a single function definition");
    };

    let [
        Stmt::Expr(assign_stmt),
        Stmt::Expr(sub_stmt),
        Stmt::Expr(logic_stmt),
        Stmt::Return(_),
    ] = &body.stmts[..]
    else {
        panic!("expected three expression statements followed by return");
    };

    match assign_stmt
        .expr
        .as_ref()
        .expect("assignment statement should have an expression")
    {
        Expr::Assign(assign) => {
            assert_eq!(assign.op, AssignOp::Assign);
            assert!(matches!(assign.lhs.as_ref(), Expr::Name(name) if name.name == "a"));
            match assign.rhs.as_ref() {
                Expr::Assign(inner) => {
                    assert_eq!(inner.op, AssignOp::Assign);
                    assert!(matches!(inner.lhs.as_ref(), Expr::Name(name) if name.name == "b"));
                    assert!(matches!(inner.rhs.as_ref(), Expr::Name(name) if name.name == "c"));
                }
                other => panic!("expected right-associative nested assignment, got {other:?}"),
            }
        }
        other => panic!("expected assignment expression, got {other:?}"),
    }

    match sub_stmt
        .expr
        .as_ref()
        .expect("subtraction statement should have an expression")
    {
        Expr::Binary(binary) => {
            assert_eq!(binary.op, BinaryOp::Sub);
            match binary.lhs.as_ref() {
                Expr::Binary(lhs) => {
                    assert_eq!(lhs.op, BinaryOp::Sub);
                    assert!(matches!(lhs.lhs.as_ref(), Expr::Name(name) if name.name == "x"));
                    assert!(matches!(lhs.rhs.as_ref(), Expr::Name(name) if name.name == "y"));
                }
                other => panic!("expected left-associative subtraction lhs, got {other:?}"),
            }
            assert!(matches!(binary.rhs.as_ref(), Expr::Name(name) if name.name == "z"));
        }
        other => panic!("expected subtraction expression, got {other:?}"),
    }

    match logic_stmt
        .expr
        .as_ref()
        .expect("logical statement should have an expression")
    {
        Expr::Binary(binary) => {
            assert_eq!(binary.op, BinaryOp::LogicalOr);
            assert!(matches!(binary.lhs.as_ref(), Expr::Name(name) if name.name == "p"));
            match binary.rhs.as_ref() {
                Expr::Binary(rhs) => {
                    assert_eq!(rhs.op, BinaryOp::LogicalAnd);
                    assert!(matches!(rhs.lhs.as_ref(), Expr::Name(name) if name.name == "q"));
                    assert!(matches!(rhs.rhs.as_ref(), Expr::Name(name) if name.name == "r"));
                }
                other => panic!("expected && on the rhs of ||, got {other:?}"),
            }
        }
        other => panic!("expected logical-or expression, got {other:?}"),
    }
}

#[test]
fn parser_accepts_compound_assignments_and_loop_control() {
    let program = parse_source(
        "loop_control.cpp",
        "int main() {\n    while (true) break;\n    for (;;)\n        continue;\n    x += 1;\n    y -= 2;\n    z *= 3;\n    q /= 4;\n    r %= 5;\n    return 0;\n}\n",
    );

    let [TopLevelDecl::FunctionDef(FunctionDef { body, .. })] = &program.decls[..] else {
        panic!("expected a single function definition");
    };

    let [
        Stmt::While(while_stmt),
        Stmt::For(for_stmt),
        Stmt::Expr(add_assign),
        Stmt::Expr(sub_assign),
        Stmt::Expr(mul_assign),
        Stmt::Expr(div_assign),
        Stmt::Expr(rem_assign),
        Stmt::Return(_),
    ] = &body.stmts[..]
    else {
        panic!("expected loop-control and compound-assignment statements");
    };

    assert!(matches!(while_stmt.body.as_ref(), Stmt::Break(_)));
    assert!(matches!(for_stmt.body.as_ref(), Stmt::Continue(_)));
    assert_expr_assign_op(add_assign, AssignOp::AddAssign);
    assert_expr_assign_op(sub_assign, AssignOp::SubAssign);
    assert_expr_assign_op(mul_assign, AssignOp::MulAssign);
    assert_expr_assign_op(div_assign, AssignOp::DivAssign);
    assert_expr_assign_op(rem_assign, AssignOp::RemAssign);
}

#[test]
fn parser_accepts_array_declarations_and_subscripts() {
    let program = parse_source(
        "arrays.cpp",
        "int main() {\n    int a[3];\n    bool seen[2];\n    a[0] = 1;\n    seen[1] = false;\n    return a[0];\n}\n",
    );

    let [TopLevelDecl::FunctionDef(FunctionDef { body, .. })] = &program.decls[..] else {
        panic!("expected a single function definition");
    };

    let [
        Stmt::Decl(int_array),
        Stmt::Decl(bool_array),
        Stmt::Expr(write_int),
        Stmt::Expr(write_bool),
        Stmt::Return(ret),
    ] = &body.stmts[..]
    else {
        panic!("expected array declarations, element writes, and a return");
    };

    assert_eq!(int_array.ty, Type::Int);
    assert_eq!(int_array.array_len, Some(3));
    assert_eq!(bool_array.ty, Type::Bool);
    assert_eq!(bool_array.array_len, Some(2));

    match write_int.expr.as_ref() {
        Some(Expr::Assign(assign)) => {
            assert_eq!(assign.op, AssignOp::Assign);
            match assign.lhs.as_ref() {
                Expr::Subscript(subscript) => {
                    assert!(matches!(
                        subscript.base.as_ref(),
                        Expr::Name(name) if name.name == "a"
                    ));
                    assert!(matches!(
                        subscript.index.as_ref(),
                        Expr::IntLiteral(lit) if lit.value == 0
                    ));
                }
                other => panic!("expected int array subscript assignment lhs, got {other:?}"),
            }
        }
        other => panic!("expected int array assignment expression, got {other:?}"),
    }

    match write_bool.expr.as_ref() {
        Some(Expr::Assign(assign)) => match assign.lhs.as_ref() {
            Expr::Subscript(subscript) => {
                assert!(matches!(
                    subscript.base.as_ref(),
                    Expr::Name(name) if name.name == "seen"
                ));
                assert!(matches!(
                    subscript.index.as_ref(),
                    Expr::IntLiteral(lit) if lit.value == 1
                ));
            }
            other => panic!("expected bool array subscript assignment lhs, got {other:?}"),
        },
        other => panic!("expected bool array assignment expression, got {other:?}"),
    }

    match ret.expr.as_ref() {
        Some(Expr::Subscript(subscript)) => {
            assert!(matches!(
                subscript.base.as_ref(),
                Expr::Name(name) if name.name == "a"
            ));
            assert!(matches!(
                subscript.index.as_ref(),
                Expr::IntLiteral(lit) if lit.value == 0
            ));
        }
        other => panic!("expected array subscript return expression, got {other:?}"),
    }
}

#[test]
fn parser_accepts_parenthesized_array_element_assignments() {
    let program = parse_source(
        "paren_array_assign.cpp",
        "int main() {\n    int a[1];\n    (a[0]) = 1;\n    (a[0]) += 2;\n    return a[0];\n}\n",
    );

    let [TopLevelDecl::FunctionDef(FunctionDef { body, .. })] = &program.decls[..] else {
        panic!("expected a single function definition");
    };

    let [
        Stmt::Decl(_),
        Stmt::Expr(assign),
        Stmt::Expr(add_assign),
        Stmt::Return(_),
    ] = &body.stmts[..]
    else {
        panic!("expected declaration, two assignments, and return");
    };

    match assign.expr.as_ref() {
        Some(Expr::Assign(assign)) => {
            assert_eq!(assign.op, AssignOp::Assign);
            assert!(matches!(assign.lhs.as_ref(), Expr::Paren(_)));
        }
        other => panic!("expected parenthesized assignment, got {other:?}"),
    }

    match add_assign.expr.as_ref() {
        Some(Expr::Assign(assign)) => {
            assert_eq!(assign.op, AssignOp::AddAssign);
            assert!(matches!(assign.lhs.as_ref(), Expr::Paren(_)));
        }
        other => panic!("expected parenthesized compound assignment, got {other:?}"),
    }
}

#[test]
fn parser_rejects_invalid_array_declarators() {
    let (_, rendered) = parse_source_with_diags(
        "invalid_arrays.cpp",
        "int main() {\n    int zero[0];\n    int neg[-1];\n    int dyn[n];\n    int init[2] = 1;\n}\n",
    );

    assert!(
        rendered.contains("array size must be a positive integer literal"),
        "expected positive-size diagnostic, got:\n{rendered}"
    );
    assert!(
        rendered.contains("initialized arrays are unsupported"),
        "expected initialized-array diagnostic, got:\n{rendered}"
    );
}

#[test]
fn parser_reports_out_of_range_integer_literals_without_panicking() {
    let (program, rendered) =
        parse_source_with_diags("overflow.cpp", "int main() {\n    return 2147483648;\n}\n");

    assert_eq!(
        program.decls.len(),
        1,
        "the surrounding function should still parse"
    );
    assert!(
        rendered.contains("error[NPP2004]: integer literal is out of range for 'int'"),
        "expected range diagnostic, got:\n{rendered}"
    );
}

#[test]
fn parser_preserves_spans_for_empty_statement_bodies() {
    let mut sm = SourceManager::new();
    sm.add_file(
        "first.cpp".to_owned(),
        "int ignored() { return 0; }\n".to_owned(),
    );
    let file = sm.add_file(
        "second.cpp".to_owned(),
        "int main() {\n    if (true) ;\n    while (false) ;\n    for (;;)\n        ;\n    return 0;\n}\n"
            .to_owned(),
    );

    let mut diags = DiagEngine::new();
    let program = parse(&sm, file, &mut diags);
    assert!(
        !diags.has_errors(),
        "expected parser success, got:\n{}",
        support::normalize_newlines(&diags.render_to_string(&sm))
    );

    let [TopLevelDecl::FunctionDef(FunctionDef { body, .. })] = &program.decls[..] else {
        panic!("expected a single function definition");
    };

    let [
        Stmt::If(if_stmt),
        Stmt::While(while_stmt),
        Stmt::For(for_stmt),
        Stmt::Return(_),
    ] = &body.stmts[..]
    else {
        panic!("expected empty-body control-flow statements");
    };

    assert_stmt_in_file(if_stmt.then_branch.as_ref(), file);
    assert_stmt_in_file(while_stmt.body.as_ref(), file);
    assert_stmt_in_file(for_stmt.body.as_ref(), file);
    assert!(if_stmt.span.end > if_stmt.span.start);
    assert!(while_stmt.span.end > while_stmt.span.start);
    assert!(for_stmt.span.end > for_stmt.span.start);
}

fn fixture_paths(dir: &Path) -> Vec<PathBuf> {
    fs::read_dir(dir)
        .unwrap_or_else(|err| panic!("failed to read fixture directory {}: {err}", dir.display()))
        .map(|entry| {
            entry
                .expect("fixture directory entries should be readable")
                .path()
        })
        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("cpp"))
        .collect()
}

fn parse_source(name: &str, source: &str) -> Program {
    let (program, rendered) = parse_source_with_diags(name, source);
    assert!(
        !rendered.contains("error["),
        "expected parser success, got:\n{rendered}"
    );
    program
}

fn parse_source_with_diags(name: &str, source: &str) -> (Program, String) {
    let mut sm = SourceManager::new();
    let file = sm.add_file(name.to_owned(), source.to_owned());
    let mut diags = DiagEngine::new();
    let program = parse(&sm, file, &mut diags);
    let rendered = support::normalize_newlines(&diags.render_to_string(&sm));
    (program, rendered)
}

fn render_snapshot(sm: &SourceManager, program: &Program, diags: &DiagEngine) -> String {
    let mut out = render_ast(program);
    out.push_str("diagnostics:\n");
    if diags.diagnostics().is_empty() {
        out.push_str("<none>\n");
    } else {
        out.push_str(&support::normalize_newlines(&diags.render_to_string(sm)));
    }
    out
}

fn assert_expr_assign_op(stmt: &ExprStmt, expected: AssignOp) {
    match stmt.expr.as_ref() {
        Some(Expr::Assign(assign)) => assert_eq!(assign.op, expected),
        other => panic!("expected assignment expression, got {other:?}"),
    }
}

fn assert_stmt_in_file(stmt: &Stmt, file: notplusplus::source::FileId) {
    match stmt {
        Stmt::Expr(expr_stmt) => {
            assert_eq!(expr_stmt.span.file, file);
            assert!(expr_stmt.span.end >= expr_stmt.span.start);
        }
        other => panic!("expected empty expression statement, got {other:?}"),
    }
}