use std::cell::Cell;
use std::ops::ControlFlow;
use tree_sitter::{Language, ParseOptions, ParseState, Parser, Tree};
thread_local! {
static SCRATCH_PARSER: Cell<Option<Parser>> = const { Cell::new(None) };
}
crate::observation::counter!(parsers_built);
pub fn parse_on_scratch_parser(language: &Language, code: &[u8]) -> Tree {
let mut parser = SCRATCH_PARSER
.try_with(Cell::take)
.ok()
.flatten()
.unwrap_or_else(build_parser);
parser
.set_language(language)
.expect("invariant: grammar version is pinned and compatible with bundled tree-sitter");
let tree = parse_unless_cancelled(&mut parser, code).unwrap_or_else(|| {
parser.reset();
parser
.parse(b"", None)
.expect("invariant: parser has a language set and nothing stops this parse")
});
let _ = SCRATCH_PARSER.try_with(|slot| slot.set(Some(parser)));
tree
}
fn parse_unless_cancelled(parser: &mut Parser, code: &[u8]) -> Option<Tree> {
let mut stop_if_cancelled = |_: &ParseState| {
if crate::cancel::requested() {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
};
let options = ParseOptions::new().progress_callback(&mut stop_if_cancelled);
parser.parse_with_options(
&mut |offset, _| code.get(offset..).unwrap_or_default(),
None,
Some(options),
)
}
fn build_parser() -> Parser {
parsers_built::record();
Parser::new()
}
#[cfg(all(test, feature = "rust"))]
mod tests {
use super::*;
use crate::LANG;
use crate::langs::AnyParser;
use crate::langs::RustCode;
use crate::traits::LanguageInfo;
fn rust_language() -> Language {
RustCode::lang()
.get_ts_language()
.expect("rust is a default feature")
}
#[test]
fn many_parses_on_one_thread_build_one_parser() {
const PARSES: usize = 8;
std::thread::spawn(|| {
assert_eq!(
parsers_built::observed(),
0,
"a fresh thread must start with an empty slot"
);
let language = rust_language();
for i in 0..PARSES {
let tree = parse_on_scratch_parser(&language, b"fn f() { let x = 1; }");
assert!(
!tree.root_node().to_sexp().contains("ERROR"),
"parse {i} must succeed"
);
}
assert_eq!(
parsers_built::observed(),
1,
"{PARSES} parses must share one parser"
);
})
.join()
.expect("parsing thread must not panic");
}
#[test]
fn a_cancelled_parse_yields_an_empty_tree_and_a_clean_parser() {
std::thread::spawn(|| {
let language = rust_language();
let long = "fn f() { let x = 1; }\n".repeat(200);
let cancel = crate::cancel::ParseCancel::new();
cancel.cancel();
let stopped = cancel.run(|| parse_on_scratch_parser(&language, long.as_bytes()));
assert_eq!(stopped.root_node().byte_range(), 0..0);
assert_eq!(stopped.root_node().child_count(), 0);
let code = b"fn g() { let y = 2; }";
let next = parse_on_scratch_parser(&language, code);
let mut fresh = Parser::new();
fresh
.set_language(&language)
.expect("the pinned grammar loads");
let expected = fresh.parse(code, None).expect("an uncancelled parse");
assert_eq!(next.root_node().byte_range(), 0..code.len());
assert_eq!(next.root_node().to_sexp(), expected.root_node().to_sexp());
})
.join()
.expect("parsing thread must not panic");
}
#[test]
fn an_uncancelled_flag_parses_in_full() {
let language = rust_language();
let code = "fn f() { let x = 1; }\n".repeat(200);
let tree = crate::cancel::ParseCancel::new()
.run(|| parse_on_scratch_parser(&language, code.as_bytes()));
assert_eq!(tree.root_node().byte_range(), 0..code.len());
assert!(!tree.root_node().has_error());
}
#[test]
fn each_thread_builds_its_own_parser() {
let mut counts = Vec::new();
for _ in 0..3 {
let handle = std::thread::spawn(|| {
let language = rust_language();
parse_on_scratch_parser(&language, b"fn f() {}");
parse_on_scratch_parser(&language, b"fn g() {}");
parsers_built::observed()
});
counts.push(handle.join().expect("parsing thread must not panic"));
}
assert_eq!(
counts,
vec![1, 1, 1],
"each thread builds exactly one parser for its own files"
);
}
#[test]
fn repeated_parses_through_the_dispatch_seam_share_one_parser() {
const FILES: usize = 6;
std::thread::spawn(|| {
for i in 0..FILES {
let code = format!("fn f{i}() {{ let x = {i}; }}");
let parsed = AnyParser::parse(LANG::Rust, code.into_bytes(), None, None)
.expect("rust is enabled for this module");
let sexp = parsed.ts_tree().root_node().to_sexp();
assert!(
sexp.contains("function_item") && !sexp.contains("ERROR"),
"file {i} must parse to a real tree, got {sexp}"
);
}
assert_eq!(
parsers_built::observed(),
1,
"{FILES} files parsed through `AnyParser::parse` must share one parser"
);
})
.join()
.expect("parsing thread must not panic");
}
}