plum

#![allow(non_snake_case)]

use plum_checker::checkSource;

use plum_core::AstParser;

fn examplesDir() -> std::path::PathBuf {

    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples")

}

fn exampleFiles() -> Vec<std::path::PathBuf> {

    let mut files: Vec<_> = std::fs::read_dir(examplesDir())

        .expect("examples/ directory should exist")

        .filter_map(|e| e.ok())

        .map(|e| e.path())

        .filter(|p| p.extension().and_then(|e| e.to_str()) == Some("plum"))

        .collect();

    files.sort();

    assert!(!files.is_empty(), "examples/ should contain at least one .plum file");

    files

}

/// Every example must parse with zero ERROR/MISSING nodes and pass `checkSource`.

/// These files exist specifically to prove each piece of the currently-supported

/// grammar surface actually works end to end, not just in isolated unit tests.

#[test]

fn everyExampleParsesAndTypeChecks() {

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

    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();

    for path in exampleFiles() {

        let src = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));

        let tree = parser.parse(&src, None).unwrap_or_else(|| panic!("failed to parse {}", path.display()));

        assert!(

            !tree.root_node().has_error(),

            "{} has a parse error:\n{}",

            path.display(),

            tree.root_node().to_sexp()

        );

        let ap = AstParser::new(&src);

        let source = ap.parseSource(tree.root_node());

        let result = checkSource(&source);

        assert!(

            result.is_ok(),

            "{} failed type checking: {:?}",

            path.display(),

            result.err().map(|errs| errs.into_iter().map(|e| e.message).collect::<Vec<_>>())

        );

    }

}