pub fn detect_errors(source: &str, cst: &Tree) -> Vec<Diagnostic> {

    let mut diagnostics: Vec<Diagnostic> = Vec::new();

    let mut errors: Vec<RecoverableParseError> = vec![];

    let context = Arc::new(RwLock::new(Context::default()));

    let _ = parse_essence_with_context_and_map(source, context, &mut errors, Some(cst));

    diagnostics.extend(errors.into_iter().map(|e| error_to_diagnostic(&e)));

    diagnostics

}

pub fn error_to_diagnostic(err: &RecoverableParseError) -> Diagnostic {

    let (start, end) = range_to_position(&err.range);

    Diagnostic {

        range: Range { start, end },

        severity: Severity::Error,

        source: "semantic error detection",

        message: err.msg.clone(),

    }

}

fn range_to_position(range: &Option<tree_sitter::Range>) -> (Position, Position) {

    match range {

        Some(r) => (

            Position {

                line: r.start_point.row as u32,

                character: r.start_point.column as u32,

            },

            Position {

                line: r.end_point.row as u32,

                character: r.end_point.column as u32,

            },

        ),

}

pub fn check_diagnostic(

    diag: &Diagnostic,

    line_start: u32,

    char_start: u32,

    line_end: u32,

    char_end: u32,

    msg: &str,

) {

    assert_eq!(diag.range.start.line, line_start);

    assert_eq!(diag.range.start.character, char_start);

    assert_eq!(diag.range.end.line, line_end);

    assert_eq!(diag.range.end.character, char_end);

    assert_eq!(diag.message, msg);

}