traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Introduce language ref-count management C APIs, remove Copy impl for Language in Rust

Browse source
This commit is contained in:
Max Brunsfeld 2023-11-27 15:50:08 -08:00
parent 660481dbf7
commit da16cb1459
27 changed files with 363 additions and 314 deletions
Download patch file Download diff file Expand all files Collapse all files

4
cli/benches/benchmark.rs
View file

@ -92,7 +92,7 @@ fn main() {
eprintln!("\nLanguage: {}", language_name);
let language = get_language(language_path);
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
eprintln!(" Constructing Queries");
for path in query_paths {
@ -103,7 +103,7 @@ fn main() {
}
parse(&path, max_path_length, |source| {
Query::new(language, str::from_utf8(source).unwrap())
Query::new(&language, str::from_utf8(source).unwrap())
.with_context(|| format!("Query file path: {path:?}"))
.expect("Failed to parse query");
});

2
cli/loader/src/lib.rs
View file

@ -324,7 +324,7 @@ impl Loader {
let src_path = path.join("src");
self.load_language_at_path(&src_path, &src_path)
})
.map(|l| *l)
.cloned()
}
pub fn load_language_at_path(&self, src_path: &Path, header_path: &Path) -> Result<Language> {

16
cli/src/main.rs
View file

@ -414,7 +414,7 @@ fn run() -> Result<()> {
let language = languages
.first()
.ok_or_else(|| anyhow!("No language found"))?;
parser.set_language(*language)?;
parser.set_language(&language)?;
let test_dir = current_dir.join("test");
@ -435,7 +435,7 @@ fn run() -> Result<()> {
}
// Check that all of the queries are valid.
test::check_queries_at_path(*language, &current_dir.join("queries"))?;
test::check_queries_at_path(language.clone(), &current_dir.join("queries"))?;
// Run the syntax highlighting tests.
let test_highlight_dir = test_dir.join("highlight");
@ -527,11 +527,11 @@ fn run() -> Result<()> {
let language =
loader.select_language(path, &current_dir, matches.value_of("scope"))?;
parser
.set_language(language)
.set_language(&language)
.context("incompatible language")?;
let opts = ParseFileOptions {
language,
language: language.clone(),
path,
edits: &edits,
max_path_length,
@ -636,10 +636,10 @@ fn run() -> Result<()> {
let cancellation_flag = util::cancel_on_signal();
let mut lang = None;
let mut language = None;
if let Some(scope) = matches.value_of("scope") {
lang = loader.language_configuration_for_scope(scope)?;
if lang.is_none() {
language = loader.language_configuration_for_scope(scope)?;
if language.is_none() {
return Err(anyhow!("Unknown scope '{}'", scope));
}
}
@ -655,7 +655,7 @@ fn run() -> Result<()> {
for path in paths {
let path = Path::new(&path);
let (language, language_config) = match lang {
let (language, language_config) = match language.clone() {
Some(v) => v,
None => match loader.language_configuration_for_file_name(path)? {
Some(v) => v,

2
cli/src/parse.rs
View file

@ -54,7 +54,7 @@ pub struct ParseFileOptions<'a> {
pub fn parse_file_at_path(parser: &mut Parser, opts: ParseFileOptions) -> Result<bool> {
let mut _log_session = None;
parser.set_language(opts.language)?;
parser.set_language(&opts.language)?;
let mut source_code = fs::read(opts.path)
.with_context(|| format!("Error reading source file {:?}", opts.path))?;

6
cli/src/query.rs
View file

@ -25,7 +25,7 @@ pub fn query_files_at_paths(
let query_source = fs::read_to_string(query_path)
.with_context(|| format!("Error reading query file {:?}", query_path))?;
let query = Query::new(language, &query_source).with_context(|| "Query compilation failed")?;
let query = Query::new(&language, &query_source).with_context(|| "Query compilation failed")?;
let mut query_cursor = QueryCursor::new();
if let Some(range) = byte_range {
@ -36,7 +36,7 @@ pub fn query_files_at_paths(
}
let mut parser = Parser::new();
parser.set_language(language)?;
parser.set_language(&language)?;
for path in paths {
let mut results = Vec::new();
@ -115,7 +115,7 @@ pub fn query_files_at_paths(
)?;
}
if should_test {
query_testing::assert_expected_captures(results, path, &mut parser, language)?
query_testing::assert_expected_captures(results, path, &mut parser, language.clone())?
}
if print_time {
writeln!(&mut stdout, "{:?}", start.elapsed())?;

2
cli/src/query_testing.rs
View file

@ -45,7 +45,7 @@ pub fn parse_position_comments(
// Parse the code.
parser.set_included_ranges(&[]).unwrap();
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse(source, None).unwrap();
// Walk the tree, finding comment nodes that contain assertions.

2
cli/src/tags.rs
View file

@ -29,7 +29,7 @@ pub fn generate_tags(
for path in paths {
let path = Path::new(&path);
let (language, language_config) = match lang {
let (language, language_config) = match lang.clone() {
Some(v) => v,
None => match loader.language_configuration_for_file_name(path)? {
Some(v) => v,

2
cli/src/test.rs
View file

@ -141,7 +141,7 @@ pub fn check_queries_at_path(language: Language, path: &Path) -> Result<()> {
let filepath = entry.file_name().to_str().unwrap_or("");
let content = fs::read_to_string(entry.path())
.with_context(|| format!("Error reading query file {:?}", filepath))?;
Query::new(language, &content)
Query::new(&language, &content)
.with_context(|| format!("Error in query file {:?}", filepath))?;
}
}

7
cli/src/test_highlight.rs
View file

@ -197,8 +197,11 @@ pub fn test_highlight(
// Highlight the file, and parse out all of the highlighting assertions.
let highlight_names = loader.highlight_names();
let highlights = get_highlight_positions(loader, highlighter, highlight_config, source)?;
let assertions =
parse_position_comments(highlighter.parser(), highlight_config.language, source)?;
let assertions = parse_position_comments(
highlighter.parser(),
highlight_config.language.clone(),
source,
)?;
iterate_assertions(&assertions, &highlights, &highlight_names)
}

3
cli/src/test_tags.rs
View file

@ -88,7 +88,8 @@ pub fn test_tag(
source: &[u8],
) -> Result<usize> {
let tags = get_tag_positions(tags_context, tags_config, source)?;
let assertions = parse_position_comments(tags_context.parser(), tags_config.language, source)?;
let assertions =
parse_position_comments(tags_context.parser(), tags_config.language.clone(), source)?;
// Iterate through all of the assertions, checking against the actual tags.
let mut i = 0;

8
cli/src/tests/async_context_test.rs
View file

@ -10,7 +10,7 @@ fn test_node_in_fut() {
let (ret, pended) = tokio_like_spawn(async {
let mut parser = Parser::new();
let language = get_language("bash");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("#", None).unwrap();
@ -64,7 +64,7 @@ fn test_node_and_cursor_ref_in_fut() {
let (_, pended) = tokio_like_spawn(async {
let mut parser = Parser::new();
let language = get_language("bash");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("#", None).unwrap();
@ -103,7 +103,7 @@ fn test_node_and_cursor_ref_in_fut_with_fut_fabrics() {
let (_, pended) = tokio_like_spawn(async {
let mut parser = Parser::new();
let language = get_language("bash");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("#", None).unwrap();
@ -141,7 +141,7 @@ fn test_node_and_cursor_ref_in_fut_with_inner_spawns() {
let (ret, pended) = tokio_like_spawn(async {
let mut parser = Parser::new();
let language = get_language("bash");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("#", None).unwrap();

8
cli/src/tests/corpus_test.rs
View file

@ -138,7 +138,7 @@ fn test_language_corpus(language_name: &str, start_seed: usize, skipped: Option<
let passed = allocations::record(|| {
let mut log_session = None;
let mut parser = get_parser(&mut log_session, "log.html");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
set_included_ranges(&mut parser, &test.input, test.template_delimiters);
let tree = parser.parse(&test.input, None).unwrap();
@ -164,7 +164,7 @@ fn test_language_corpus(language_name: &str, start_seed: usize, skipped: Option<
}
let mut parser = Parser::new();
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse(&test.input, None).unwrap();
drop(parser);
@ -174,7 +174,7 @@ fn test_language_corpus(language_name: &str, start_seed: usize, skipped: Option<
let mut rand = Rand::new(seed);
let mut log_session = None;
let mut parser = get_parser(&mut log_session, "log.html");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let mut tree = tree.clone();
let mut input = test.input.clone();
@ -356,7 +356,7 @@ fn test_feature_corpus_files() {
let passed = allocations::record(|| {
let mut log_session = None;
let mut parser = get_parser(&mut log_session, "log.html");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse(&test.input, None).unwrap();
let mut actual_output = tree.root_node().to_sexp();
if !test.has_fields {

6
cli/src/tests/github_issue_test.rs
View file

@ -14,7 +14,7 @@ use tree_sitter::Query;
#[test]
fn issue_2162_out_of_bound() {
let language = get_language("java");
assert!(Query::new(language, "(package_declaration _ (_) @name _)").is_ok());
assert!(Query::new(&language, "(package_declaration _ (_) @name _)").is_ok());
}
#[test]
@ -32,9 +32,9 @@ fn issue_2107_first_child_group_anchor_had_no_effect() {
)
)
"#};
let query = Query::new(language, query).unwrap();
let query = Query::new(&language, query).unwrap();
assert_query_matches(
language,
&language,
&query,
source_code,
&[(0, vec![("constant", "int a")])],

4
cli/src/tests/helpers/query_helpers.rs
View file

@ -308,13 +308,13 @@ fn compare_depth_first(a: Node, b: Node) -> Ordering {
}
pub fn assert_query_matches(
language: Language,
language: &Language,
query: &Query,
source: &str,
expected: &[(usize, Vec<(&str, &str)>)],
) {
let mut parser = Parser::new();
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse(source, None).unwrap();
let mut cursor = QueryCursor::new();
let matches = cursor.matches(&query, tree.root_node(), source.as_bytes());

6
cli/src/tests/language_test.rs
View file

@ -5,7 +5,7 @@ use tree_sitter::Parser;
fn test_lookahead_iterator() {
let mut parser = Parser::new();
let language = get_language("rust");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("struct Stuff {}", None).unwrap();
@ -34,7 +34,7 @@ fn test_lookahead_iterator() {
lookahead.reset_state(next_state);
assert!(lookahead.iter_names().eq(expected_symbols));
lookahead.reset(language, next_state);
lookahead.reset(language.clone(), next_state);
assert!(lookahead
.map(|s| language.node_kind_for_id(s).unwrap())
.eq(expected_symbols));
@ -44,7 +44,7 @@ fn test_lookahead_iterator() {
fn test_lookahead_iterator_modifiable_only_by_mut() {
let mut parser = Parser::new();
let language = get_language("rust");
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("struct Stuff {}", None).unwrap();

30
cli/src/tests/node_test.rs
View file

@ -202,7 +202,7 @@ fn test_node_children() {
#[test]
fn test_node_children_by_field_name() {
let mut parser = Parser::new();
parser.set_language(get_language("python")).unwrap();
parser.set_language(&get_language("python")).unwrap();
let source = "
if one:
a()
@ -230,7 +230,7 @@ fn test_node_children_by_field_name() {
#[test]
fn test_node_parent_of_child_by_field_name() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse("foo(a().b[0].c.d.e())", None).unwrap();
let call_node = tree
.root_node()
@ -251,7 +251,7 @@ fn test_node_parent_of_child_by_field_name() {
#[test]
fn test_node_field_name_for_child() {
let mut parser = Parser::new();
parser.set_language(get_language("c")).unwrap();
parser.set_language(&get_language("c")).unwrap();
let tree = parser.parse("int w = x + y;", None).unwrap();
let translation_unit_node = tree.root_node();
let declaration_node = translation_unit_node.named_child(0).unwrap();
@ -278,7 +278,7 @@ fn test_node_field_name_for_child() {
#[test]
fn test_node_child_by_field_name_with_extra_hidden_children() {
let mut parser = Parser::new();
parser.set_language(get_language("python")).unwrap();
parser.set_language(&get_language("python")).unwrap();
// In the Python grammar, some fields are applied to `suite` nodes,
// which consist of an invisible `indent` token followed by a block.
@ -373,7 +373,7 @@ fn test_node_named_child_with_aliases_and_extras() {
let mut parser = Parser::new();
parser
.set_language(get_test_language(&parser_name, &parser_code, None))
.set_language(&get_test_language(&parser_name, &parser_code, None))
.unwrap();
let tree = parser.parse("b ... b ... c", None).unwrap();
@ -411,7 +411,7 @@ fn test_node_descendant_count() {
fn test_descendant_count_single_node_tree() {
let mut parser = Parser::new();
parser
.set_language(get_language("embedded-template"))
.set_language(&get_language("embedded-template"))
.unwrap();
let tree = parser.parse("hello", None).unwrap();
@ -576,7 +576,7 @@ fn test_node_edit() {
#[test]
fn test_root_node_with_offset() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse(" if (a) b", None).unwrap();
let node = tree.root_node_with_offset(6, Point::new(2, 2));
@ -604,7 +604,7 @@ fn test_root_node_with_offset() {
#[test]
fn test_node_is_extra() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse("foo(/* hi */);", None).unwrap();
let root_node = tree.root_node();
@ -619,7 +619,7 @@ fn test_node_is_extra() {
#[test]
fn test_node_sexp() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse("if (a) b", None).unwrap();
let root_node = tree.root_node();
let if_node = root_node.descendant_for_byte_range(0, 0).unwrap();
@ -708,7 +708,7 @@ fn test_node_field_names() {
let mut parser = Parser::new();
let language = get_test_language(&parser_name, &parser_code, None);
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser
.parse("child-0 child-1 child-2 child-3 child-4", None)
@ -778,7 +778,7 @@ fn test_node_field_calls_in_language_without_fields() {
let mut parser = Parser::new();
let language = get_test_language(&parser_name, &parser_code, None);
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("b c d", None).unwrap();
@ -807,7 +807,7 @@ fn test_node_is_named_but_aliased_as_anonymous() {
let mut parser = Parser::new();
let language = get_test_language(&parser_name, &parser_code, None);
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse("B C B", None).unwrap();
@ -826,7 +826,7 @@ fn test_node_is_named_but_aliased_as_anonymous() {
#[test]
fn test_node_numeric_symbols_respect_simple_aliases() {
let mut parser = Parser::new();
parser.set_language(get_language("python")).unwrap();
parser.set_language(&get_language("python")).unwrap();
// Example 1:
// Python argument lists can contain "splat" arguments, which are not allowed within
@ -857,7 +857,7 @@ fn test_node_numeric_symbols_respect_simple_aliases() {
// Ruby handles the unary (negative) and binary (minus) `-` operators using two different
// tokens. One or more of these is an external token that's aliased as `-`. Their numeric
// kind ids should match.
parser.set_language(get_language("ruby")).unwrap();
parser.set_language(&get_language("ruby")).unwrap();
let tree = parser.parse("-a - b", None).unwrap();
let root = tree.root_node();
assert_eq!(
@ -903,6 +903,6 @@ fn get_all_nodes(tree: &Tree) -> Vec<Node> {
fn parse_json_example() -> Tree {
let mut parser = Parser::new();
parser.set_language(get_language("json")).unwrap();
parser.set_language(&get_language("json")).unwrap();
parser.parse(JSON_EXAMPLE, None).unwrap()
}

72
cli/src/tests/parser_test.rs
View file

@ -20,7 +20,7 @@ use tree_sitter_proc_macro::retry;
#[test]
fn test_parsing_simple_string() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let tree = parser
.parse(
@ -51,7 +51,7 @@ fn test_parsing_simple_string() {
#[test]
fn test_parsing_with_logging() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let mut messages = Vec::new();
parser.set_logger(Some(Box::new(|log_type, message| {
@ -92,7 +92,7 @@ fn test_parsing_with_debug_graph_enabled() {
let has_zero_indexed_row = |s: &str| s.contains("position: 0,");
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let mut debug_graph_file = tempfile::tempfile().unwrap();
parser.print_dot_graphs(&debug_graph_file);
@ -114,7 +114,7 @@ fn test_parsing_with_debug_graph_enabled() {
#[test]
fn test_parsing_with_custom_utf8_input() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let lines = &["pub fn foo() {", " 1", "}"];
@ -157,7 +157,7 @@ fn test_parsing_with_custom_utf8_input() {
#[test]
fn test_parsing_with_custom_utf16_input() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let lines: Vec<Vec<u16>> = ["pub fn foo() {", " 1", "}"]
.iter()
@ -196,7 +196,7 @@ fn test_parsing_with_custom_utf16_input() {
#[test]
fn test_parsing_with_callback_returning_owned_strings() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let text = b"pub fn foo() { 1 }";
@ -217,7 +217,7 @@ fn test_parsing_with_callback_returning_owned_strings() {
#[test]
fn test_parsing_text_with_byte_order_mark() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
// Parse UTF16 text with a BOM
let tree = parser
@ -276,7 +276,7 @@ fn test_parsing_text_with_byte_order_mark() {
#[test]
fn test_parsing_invalid_chars_at_eof() {
let mut parser = Parser::new();
parser.set_language(get_language("json")).unwrap();
parser.set_language(&get_language("json")).unwrap();
let tree = parser.parse(b"\xdf", None).unwrap();
assert_eq!(
tree.root_node().to_sexp(),
@ -287,7 +287,7 @@ fn test_parsing_invalid_chars_at_eof() {
#[test]
fn test_parsing_unexpected_null_characters_within_source() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse(b"var \0 something;", None).unwrap();
assert_eq!(
tree.root_node().to_sexp(),
@ -298,7 +298,7 @@ fn test_parsing_unexpected_null_characters_within_source() {
#[test]
fn test_parsing_ends_when_input_callback_returns_empty() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let mut i = 0;
let source = b"abcdefghijklmnoqrs";
let tree = parser
@ -322,7 +322,7 @@ fn test_parsing_ends_when_input_callback_returns_empty() {
#[test]
fn test_parsing_after_editing_beginning_of_code() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let mut code = b"123 + 456 * (10 + x);".to_vec();
let mut tree = parser.parse(&code, None).unwrap();
@ -370,7 +370,7 @@ fn test_parsing_after_editing_beginning_of_code() {
#[test]
fn test_parsing_after_editing_end_of_code() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let mut code = b"x * (100 + abc);".to_vec();
let mut tree = parser.parse(&code, None).unwrap();
@ -418,7 +418,7 @@ fn test_parsing_after_editing_end_of_code() {
#[test]
fn test_parsing_empty_file_with_reused_tree() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let tree = parser.parse("", None);
parser.parse("", tree.as_ref());
@ -437,7 +437,7 @@ fn test_parsing_after_editing_tree_that_depends_on_column_values() {
let mut parser = Parser::new();
parser
.set_language(get_test_language(&grammar_name, &parser_code, Some(&dir)))
.set_language(&get_test_language(&grammar_name, &parser_code, Some(&dir)))
.unwrap();
let mut code = b"
@ -507,7 +507,7 @@ h + i
#[test]
fn test_parsing_after_detecting_error_in_the_middle_of_a_string_token() {
let mut parser = Parser::new();
parser.set_language(get_language("python")).unwrap();
parser.set_language(&get_language("python")).unwrap();
let mut source = b"a = b, 'c, d'".to_vec();
let tree = parser.parse(&source, None).unwrap();
@ -551,7 +551,7 @@ fn test_parsing_on_multiple_threads() {
let this_file_source = include_str!("parser_test.rs");
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let tree = parser.parse(this_file_source, None).unwrap();
let mut parse_threads = Vec::new();
@ -579,7 +579,7 @@ fn test_parsing_on_multiple_threads() {
// Reparse using the old tree as a starting point.
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
parser.parse(&prepended_source, Some(&tree_clone)).unwrap()
}));
}
@ -600,7 +600,7 @@ fn test_parsing_cancelled_by_another_thread() {
let cancellation_flag = std::sync::Arc::new(AtomicUsize::new(0));
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
unsafe { parser.set_cancellation_flag(Some(&cancellation_flag)) };
// Long input - parsing succeeds
@ -649,7 +649,7 @@ fn test_parsing_cancelled_by_another_thread() {
#[retry(10)]
fn test_parsing_with_a_timeout() {
let mut parser = Parser::new();
parser.set_language(get_language("json")).unwrap();
parser.set_language(&get_language("json")).unwrap();
// Parse an infinitely-long array, but pause after 1ms of processing.
parser.set_timeout_micros(1000);
@ -711,7 +711,7 @@ fn test_parsing_with_a_timeout() {
#[retry(10)]
fn test_parsing_with_a_timeout_and_a_reset() {
let mut parser = Parser::new();
parser.set_language(get_language("json")).unwrap();
parser.set_language(&get_language("json")).unwrap();
parser.set_timeout_micros(5);
let tree = parser.parse(
@ -768,7 +768,7 @@ fn test_parsing_with_a_timeout_and_a_reset() {
fn test_parsing_with_a_timeout_and_implicit_reset() {
allocations::record(|| {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
parser.set_timeout_micros(5);
let tree = parser.parse(
@ -779,7 +779,7 @@ fn test_parsing_with_a_timeout_and_implicit_reset() {
// Changing the parser's language implicitly resets, discarding
// the previous partial parse.
parser.set_language(get_language("json")).unwrap();
parser.set_language(&get_language("json")).unwrap();
parser.set_timeout_micros(0);
let tree = parser.parse(
"[null, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]",
@ -802,7 +802,7 @@ fn test_parsing_with_a_timeout_and_implicit_reset() {
fn test_parsing_with_timeout_and_no_completion() {
allocations::record(|| {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
parser.set_timeout_micros(5);
let tree = parser.parse(
@ -822,7 +822,7 @@ fn test_parsing_with_one_included_range() {
let source_code = "<span>hi</span><script>console.log('sup');</script>";
let mut parser = Parser::new();
parser.set_language(get_language("html")).unwrap();
parser.set_language(&get_language("html")).unwrap();
let html_tree = parser.parse(source_code, None).unwrap();
let script_content_node = html_tree.root_node().child(1).unwrap().child(1).unwrap();
assert_eq!(script_content_node.kind(), "raw_text");
@ -830,7 +830,7 @@ fn test_parsing_with_one_included_range() {
parser
.set_included_ranges(&[script_content_node.range()])
.unwrap();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let js_tree = parser.parse(source_code, None).unwrap();
assert_eq!(
@ -853,7 +853,7 @@ fn test_parsing_with_multiple_included_ranges() {
let source_code = "html `<div>Hello, ${name.toUpperCase()}, it's <b>${now()}</b>.</div>`";
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let js_tree = parser.parse(source_code, None).unwrap();
let template_string_node = js_tree
.root_node()
@ -869,7 +869,7 @@ fn test_parsing_with_multiple_included_ranges() {
let interpolation_node2 = template_string_node.child(2).unwrap();
let close_quote_node = template_string_node.child(3).unwrap();
parser.set_language(get_language("html")).unwrap();
parser.set_language(&get_language("html")).unwrap();
let html_ranges = &[
Range {
start_byte: open_quote_node.end_byte(),
@ -948,7 +948,7 @@ fn test_parsing_with_included_range_containing_mismatched_positions() {
let source_code = "<div>test</div>{_ignore_this_part_}";
let mut parser = Parser::new();
parser.set_language(get_language("html")).unwrap();
parser.set_language(&get_language("html")).unwrap();
let end_byte = source_code.find("{_ignore_this_part_").unwrap();
@ -1029,7 +1029,7 @@ fn test_parsing_utf16_code_with_errors_at_the_end_of_an_included_range() {
let end_byte = 2 * source_code.find("</script>").unwrap();
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
parser
.set_included_ranges(&[Range {
start_byte,
@ -1051,7 +1051,7 @@ fn test_parsing_with_external_scanner_that_uses_included_range_boundaries() {
let range2_end_byte = range2_start_byte + " d() ".len();
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
parser
.set_included_ranges(&[
Range {
@ -1095,7 +1095,7 @@ fn test_parsing_with_a_newly_excluded_range() {
// Parse HTML including the template directive, which will cause an error
let mut parser = Parser::new();
parser.set_language(get_language("html")).unwrap();
parser.set_language(&get_language("html")).unwrap();
let mut first_tree = parser
.parse_with(&mut chunked_input(&source_code, 3), None)
.unwrap();
@ -1182,7 +1182,7 @@ fn test_parsing_with_a_newly_included_range() {
// Parse only the first code directive as JavaScript
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
parser
.set_included_ranges(&[simple_range(range1_start, range1_end)])
.unwrap();
@ -1274,7 +1274,7 @@ fn test_parsing_with_included_ranges_and_missing_tokens() {
let mut parser = Parser::new();
parser
.set_language(get_test_language(&parser_name, &parser_code, None))
.set_language(&get_test_language(&parser_name, &parser_code, None))
.unwrap();
// There's a missing `a` token at the beginning of the code. It must be inserted
@ -1331,7 +1331,7 @@ fn test_grammars_that_can_hang_on_eof() {
let mut parser = Parser::new();
parser
.set_language(get_test_language(&parser_name, &parser_code, None))
.set_language(&get_test_language(&parser_name, &parser_code, None))
.unwrap();
parser.parse("\"", None).unwrap();
@ -1356,7 +1356,7 @@ fn test_grammars_that_can_hang_on_eof() {
.unwrap();
parser
.set_language(get_test_language(&parser_name, &parser_code, None))
.set_language(&get_test_language(&parser_name, &parser_code, None))
.unwrap();
parser.parse("\"", None).unwrap();
@ -1381,7 +1381,7 @@ fn test_grammars_that_can_hang_on_eof() {
.unwrap();
parser
.set_language(get_test_language(&parser_name, &parser_code, None))
.set_language(&get_test_language(&parser_name, &parser_code, None))
.unwrap();
parser.parse("\"", None).unwrap();
}

2
cli/src/tests/pathological_test.rs
View file

@ -8,7 +8,7 @@ fn test_pathological_example_1() {
allocations::record(|| {
let mut parser = Parser::new();
parser.set_language(get_language(language)).unwrap();
parser.set_language(&get_language(language)).unwrap();
parser.parse(source, None).unwrap();
});
}

417
cli/src/tests/query_test.rs
View file

File diff suppressed because it is too large Load diff

6
cli/src/tests/text_provider_test.rs
View file

@ -6,7 +6,7 @@ use tree_sitter::{Language, Node, Parser, Point, Query, QueryCursor, TextProvide
fn parse_text(text: impl AsRef<[u8]>) -> (Tree, Language) {
let language = get_language("c");
let mut parser = Parser::new();
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
(parser.parse(text, None).unwrap(), language)
}
@ -17,7 +17,7 @@ where
{
let language = get_language("c");
let mut parser = Parser::new();
parser.set_language(language).unwrap();
parser.set_language(&language).unwrap();
let tree = parser.parse_with(callback, None).unwrap();
// eprintln!("{}", tree.clone().root_node().to_sexp());
assert_eq!("comment", tree.clone().root_node().child(0).unwrap().kind());
@ -25,7 +25,7 @@ where
}
fn tree_query<I: AsRef<[u8]>>(tree: &Tree, text: impl TextProvider<I>, language: Language) {
let query = Query::new(language, "((comment) @c (#eq? @c \"// comment\"))").unwrap();
let query = Query::new(&language, "((comment) @c (#eq? @c \"// comment\"))").unwrap();
let mut cursor = QueryCursor::new();
let mut captures = cursor.captures(&query, tree.root_node(), text);
let (match_, idx) = captures.next().unwrap();

16
cli/src/tests/tree_test.rs
View file

@ -7,7 +7,7 @@ use tree_sitter::{InputEdit, Parser, Point, Range, Tree};
#[test]
fn test_tree_edit() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse(" abc !== def", None).unwrap();
assert_eq!(
@ -235,7 +235,7 @@ fn test_tree_edit() {
#[test]
fn test_tree_edit_with_included_ranges() {
let mut parser = Parser::new();
parser.set_language(get_language("html")).unwrap();
parser.set_language(&get_language("html")).unwrap();
let source = "<div><% if a %><span>a</span><% else %><span>b</span><% end %></div>";
@ -300,7 +300,7 @@ fn test_tree_edit_with_included_ranges() {
#[test]
fn test_tree_cursor() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let tree = parser
.parse(
@ -379,7 +379,7 @@ fn test_tree_cursor() {
#[test]
fn test_tree_cursor_previous_sibling() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let text = "
// Hi there
@ -418,7 +418,7 @@ fn test_tree_cursor_previous_sibling() {
#[test]
fn test_tree_cursor_fields() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser
.parse("function /*1*/ bar /*2*/ () {}", None)
@ -455,7 +455,7 @@ fn test_tree_cursor_fields() {
#[test]
fn test_tree_cursor_child_for_point() {
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let source = &"
[
one,
@ -562,7 +562,7 @@ fn test_tree_cursor_child_for_point() {
#[test]
fn test_tree_node_equality() {
let mut parser = Parser::new();
parser.set_language(get_language("rust")).unwrap();
parser.set_language(&get_language("rust")).unwrap();
let tree = parser.parse("struct A {}", None).unwrap();
let node1 = tree.root_node();
let node2 = tree.root_node();
@ -576,7 +576,7 @@ fn test_get_changed_ranges() {
let source_code = b"{a: null};\n".to_vec();
let mut parser = Parser::new();
parser.set_language(get_language("javascript")).unwrap();
parser.set_language(&get_language("javascript")).unwrap();
let tree = parser.parse(&source_code, None).unwrap();
assert_eq!(

6
highlight/src/lib.rs
View file

@ -267,7 +267,7 @@ impl HighlightConfiguration {
// Construct a single query by concatenating the three query strings, but record the
// range of pattern indices that belong to each individual string.
let mut query = Query::new(language, &query_source)?;
let mut query = Query::new(&language, &query_source)?;
let mut locals_pattern_index = 0;
let mut highlights_pattern_index = 0;
for i in 0..(query.pattern_count()) {
@ -284,7 +284,7 @@ impl HighlightConfiguration {
// Construct a separate query just for dealing with the 'combined injections'.
// Disable the combined injection patterns in the main query.
let mut combined_injections_query = Query::new(language, injection_query)?;
let mut combined_injections_query = Query::new(&language, injection_query)?;
let mut has_combined_queries = false;
for pattern_index in 0..locals_pattern_index {
let settings = query.property_settings(pattern_index);
@ -435,7 +435,7 @@ impl<'a> HighlightIterLayer<'a> {
if highlighter.parser.set_included_ranges(&ranges).is_ok() {
highlighter
.parser
.set_language(config.language)
.set_language(&config.language)
.map_err(|_| Error::InvalidLanguage)?;
unsafe { highlighter.parser.set_cancellation_flag(cancellation_flag) };

8
lib/binding_rust/bindings.rs
View file

@ -664,6 +664,14 @@ extern "C" {
#[doc = " Set the maximum start depth for a query cursor.\n\n This prevents cursors from exploring children nodes at a certain depth.\n Note if a pattern includes many children, then they will still be checked.\n\n The zero max start depth value can be used as a special behavior and\n it helps to destructure a subtree by staying on a node and using captures\n for interested parts. Note that the zero max start depth only limit a search\n depth for a pattern's root node but other nodes that are parts of the pattern\n may be searched at any depth what defined by the pattern structure.\n\n Set to `UINT32_MAX` to remove the maximum start depth."]
pub fn ts_query_cursor_set_max_start_depth(self_: *mut TSQueryCursor, max_start_depth: u32);
}
extern "C" {
#[doc = " Get another reference to the given language."]
pub fn ts_language_copy(self_: *const TSLanguage) -> *const TSLanguage;
}
extern "C" {
#[doc = " Free any dynamically-allocated resources for this language, if\n this is the last reference."]
pub fn ts_language_delete(self_: *const TSLanguage);
}
extern "C" {
#[doc = " Get the number of distinct node types in the language."]
pub fn ts_language_symbol_count(self_: *const TSLanguage) -> u32;

18
lib/binding_rust/lib.rs
View file

@ -47,7 +47,7 @@ pub const PARSER_HEADER: &'static str = include_str!("../include/tree_sitter/par
/// An opaque object that defines how to parse a particular language. The code for each
/// `Language` is generated by the Tree-sitter CLI.
#[doc(alias = "TSLanguage")]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct Language(*const ffi::TSLanguage);
@ -385,6 +385,18 @@ impl Language {
}
}
impl Clone for Language {
fn clone(&self) -> Self {
unsafe { Self(ffi::ts_language_copy(self.0)) }
}
}
impl Drop for Language {
fn drop(&mut self) {
unsafe { ffi::ts_language_delete(self.0) }
}
}
impl Parser {
/// Create a new parser.
pub fn new() -> Parser {
@ -403,7 +415,7 @@ impl Parser {
/// and compare it to this library's [`LANGUAGE_VERSION`](LANGUAGE_VERSION) and
/// [`MIN_COMPATIBLE_LANGUAGE_VERSION`](MIN_COMPATIBLE_LANGUAGE_VERSION) constants.
#[doc(alias = "ts_parser_set_language")]
pub fn set_language(&mut self, language: Language) -> Result<(), LanguageError> {
pub fn set_language(&mut self, language: &Language) -> Result<(), LanguageError> {
let version = language.version();
if version < MIN_COMPATIBLE_LANGUAGE_VERSION || version > LANGUAGE_VERSION {
Err(LanguageError { version })
@ -1553,7 +1565,7 @@ impl Query {
/// The query is associated with a particular language, and can only be run
/// on syntax nodes parsed with that language. References to Queries can be
/// shared between multiple threads.
pub fn new(language: Language, source: &str) -> Result<Self, QueryError> {
pub fn new(language: &Language, source: &str) -> Result<Self, QueryError> {
let mut error_offset = 0u32;
let mut error_type: ffi::TSQueryError = 0;
let bytes = source.as_bytes();

11
lib/include/tree_sitter/api.h
View file

@ -1013,6 +1013,17 @@ void ts_query_cursor_set_max_start_depth(TSQueryCursor *self, uint32_t max_start
/* Section - Language */
/**********************/
/**
* Get another reference to the given language.
*/
const TSLanguage *ts_language_copy(const TSLanguage *self);
/**
* Free any dynamically-allocated resources for this language, if
* this is the last reference.
*/
void ts_language_delete(const TSLanguage *self);
/**
* Get the number of distinct node types in the language.
*/

9
lib/src/language.c
View file

@ -1,6 +1,15 @@
#include "./language.h"
#include <string.h>
const TSLanguage *ts_language_copy(const TSLanguage *self) {
// TODO - increment reference count for wasm languages
return self;
}
void ts_language_delete(const TSLanguage *_self) {
// TODO - decrement reference count for wasm languages
}
uint32_t ts_language_symbol_count(const TSLanguage *self) {
return self->symbol_count + self->alias_count;
}

4
tags/src/lib.rs
View file

@ -117,7 +117,7 @@ struct LineInfo {
impl TagsConfiguration {
pub fn new(language: Language, tags_query: &str, locals_query: &str) -> Result<Self, Error> {
let query = Query::new(language, &format!("{}{}", locals_query, tags_query))?;
let query = Query::new(&language, &format!("{}{}", locals_query, tags_query))?;
let tags_query_offset = locals_query.len();
let mut tags_pattern_index = 0;
@ -265,7 +265,7 @@ impl TagsContext {
cancellation_flag: Option<&'a AtomicUsize>,
) -> Result<(impl Iterator<Item = Result<Tag, Error>> + 'a, bool), Error> {
self.parser
.set_language(config.language)
.set_language(&config.language)
.map_err(|_| Error::InvalidLanguage)?;
self.parser.reset();
unsafe { self.parser.set_cancellation_flag(cancellation_flag) };