1347 lines
48 KiB
Rust
1347 lines
48 KiB
Rust
use super::*;
|
||
|
||
fn lines(source: &str) -> Vec<String> {
|
||
source.split('\n').map(str::to_owned).collect()
|
||
}
|
||
|
||
#[test]
|
||
fn scopes_follow_real_declarations_and_each_sources_own_tree() {
|
||
let original =
|
||
"impl State {\n fn old() {\n call();\n }\n}\n\nfn next() {\n call();\n}\n";
|
||
let before = cache(original, "old.rs");
|
||
let mut live = cache(&original.replace("old()", "renamed()"), "new.rs");
|
||
assert_eq!(
|
||
before.scope_at(2),
|
||
Some(ScopeContext {
|
||
start_row: 1,
|
||
end_row: 4,
|
||
name: Point::new(1, 7),
|
||
label: "impl State › old",
|
||
})
|
||
);
|
||
assert_eq!(before.scope_at(3).unwrap().label, "impl State › old");
|
||
assert_eq!(before.scope_at(4).unwrap().label, "impl State");
|
||
assert_eq!(before.scope_at(5), None);
|
||
assert_eq!(
|
||
before.scope_at(6),
|
||
Some(ScopeContext {
|
||
start_row: 6,
|
||
end_row: 9,
|
||
name: Point::new(6, 3),
|
||
label: "next",
|
||
})
|
||
);
|
||
assert_eq!(before.scope_at(9), None);
|
||
assert_eq!(before.scope_at(usize::MAX), None);
|
||
let changed = lines(&original.replace("old()", "updated()"));
|
||
live.update_visible(&changed, Some(Path::new("new.rs")), 1, &[2..3]);
|
||
assert_eq!(live.scope_at(2).unwrap().label, "impl State › updated");
|
||
assert_eq!(before.scope_at(2).unwrap().label, "impl State › old");
|
||
let counts = live.parse_counts();
|
||
live.update_visible(&changed, Some(Path::new("new.rs")), 2, &[6..9]);
|
||
assert_eq!(live.parse_counts(), counts);
|
||
live.update_visible(&changed, Some(Path::new("renamed.txt")), 2, &[0..1]);
|
||
assert_eq!(live.scope_at(2), None);
|
||
assert_eq!(before.scope_at(2).unwrap().label, "impl State › old");
|
||
let incomplete = cache("impl State {\n fn run() {\n let = ;\n }\n}", "a.rs");
|
||
assert_eq!(incomplete.scope_at(2).unwrap().label, "impl State › run");
|
||
|
||
let python = cache(
|
||
"class State:\n @decorator\n def run(self):\n work()\n\n def next(self):\n work()\n",
|
||
"a.py",
|
||
);
|
||
assert_eq!(
|
||
python.scope_at(1),
|
||
Some(ScopeContext {
|
||
start_row: 1,
|
||
end_row: 4,
|
||
name: Point::new(2, 8),
|
||
label: "State › run",
|
||
})
|
||
);
|
||
assert_eq!(python.scope_at(4).unwrap().label, "State");
|
||
assert_eq!(python.scope_at(5).unwrap().label, "State › next");
|
||
assert_eq!(python.scope_at(7), None);
|
||
|
||
for (path, source, expected) in [
|
||
(
|
||
"a.rs",
|
||
"trait State {\n fn run(&self) {\n work();\n }\n}",
|
||
Some("State › run"),
|
||
),
|
||
(
|
||
"a.rb",
|
||
"class State\n def run\n work\n end\nend",
|
||
Some("State › run"),
|
||
),
|
||
(
|
||
"a.js",
|
||
"function outer() {\n function inner() {\n work();\n }\n}",
|
||
Some("outer › inner"),
|
||
),
|
||
(
|
||
"a.ts",
|
||
"class State {\n run = () => {\n work();\n };\n}",
|
||
Some("State › run"),
|
||
),
|
||
(
|
||
"a.tsx",
|
||
"const View = () => {\n work();\n return <main />;\n};",
|
||
Some("View"),
|
||
),
|
||
(
|
||
"a.js",
|
||
"const handlers = { run: () => {\n work();\n} };",
|
||
Some("run"),
|
||
),
|
||
(
|
||
"a.js",
|
||
"State.run = () => {\n work();\n};",
|
||
Some("State.run"),
|
||
),
|
||
(
|
||
"a.go",
|
||
"package main\nfunc (s *State) run() {\n work()\n}",
|
||
Some("*State › run"),
|
||
),
|
||
(
|
||
"a.go",
|
||
"package main\nfunc run() {\n work()\n}",
|
||
Some("run"),
|
||
),
|
||
(
|
||
"a.c",
|
||
"int run(void) {\n work();\n return 7;\n}",
|
||
Some("run"),
|
||
),
|
||
(
|
||
"a.cpp",
|
||
"class State {\n void run() {\n work();\n }\n};",
|
||
Some("State › run"),
|
||
),
|
||
(
|
||
"a.cpp",
|
||
"void State::run() {\n work();\n}",
|
||
Some("State::run"),
|
||
),
|
||
("a.sh", "run() {\n work\n}", Some("run")),
|
||
(
|
||
"a.zig",
|
||
"const State = struct {\n pub fn run() void {\n work();\n }\n};",
|
||
Some("State › run"),
|
||
),
|
||
("a.md", "```rust\nfn run() {\n work();\n}\n```", Some("run")),
|
||
(
|
||
"a.html",
|
||
"<script>\nfunction run() {\n work();\n}\n</script>",
|
||
Some("run"),
|
||
),
|
||
("a.js", "use(() => {\n work();\n});", None),
|
||
(
|
||
"a.js",
|
||
"const handlers = { [key]: () => {\n work();\n} };",
|
||
None,
|
||
),
|
||
("a.txt", "fn run() {\n work();\n}", None),
|
||
("a.unknown", "fn run() {\n work();\n}", None),
|
||
("a.json", "{\"work\": \"function run() {}\"}", None),
|
||
("a.yaml", "work: function run() {}", None),
|
||
] {
|
||
let syntax = cache(source, path);
|
||
let row = source[..source.find("work").unwrap()]
|
||
.bytes()
|
||
.filter(|byte| *byte == b'\n')
|
||
.count();
|
||
assert_eq!(
|
||
syntax.scope_at(row).map(|scope| scope.label),
|
||
expected,
|
||
"{path}: {source}"
|
||
);
|
||
if let Some(scope) = syntax.scope_at(row) {
|
||
assert!(scope.start_row <= row && row < scope.end_row, "{path}");
|
||
}
|
||
}
|
||
}
|
||
|
||
fn source_range(source: &str) -> Range {
|
||
Range {
|
||
start_byte: 0,
|
||
end_byte: source.len(),
|
||
start_point: Point::new(0, 0),
|
||
end_point: point_at(source, source.len()),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn string_newlines_remain_literal_across_visible_row_caching_and_edits() {
|
||
let source = "text = \"\"\"a\n\nb\"\"\"\nplain\n";
|
||
let input = lines(source);
|
||
let path = Path::new("strings.py");
|
||
let mut cache = SyntaxCache::new();
|
||
let includes_newline = |cache: &SyntaxCache, row: usize, length: usize| {
|
||
cache
|
||
.string_spans(row)
|
||
.iter()
|
||
.any(|span| span.start_byte <= length && span.end_byte > length)
|
||
};
|
||
cache.update_visible(&input, Some(path), 0, std::slice::from_ref(&(0..1)));
|
||
assert!(includes_newline(&cache, 0, input[0].len()));
|
||
cache.update_visible(&input, Some(path), 0, std::slice::from_ref(&(1..4)));
|
||
assert!(includes_newline(&cache, 0, input[0].len()));
|
||
assert!(includes_newline(&cache, 1, input[1].len()));
|
||
assert!(!includes_newline(&cache, 2, input[2].len()));
|
||
assert!(!includes_newline(&cache, 3, input[3].len()));
|
||
for (row, line) in input.iter().enumerate() {
|
||
assert!(
|
||
cache
|
||
.line(row)
|
||
.iter()
|
||
.all(|span| span.end_byte <= line.len())
|
||
);
|
||
}
|
||
cache.update(&lines("# a\n\nb\nplain\n"), Some(path), 1);
|
||
assert!(!includes_newline(&cache, 0, 3));
|
||
assert!(!includes_newline(&cache, 1, 0));
|
||
}
|
||
|
||
#[test]
|
||
fn visible_windows_match_full_colors_after_edits_and_scrolling_without_reparsing() {
|
||
let cases = [
|
||
(
|
||
"a.rs",
|
||
"fn main() {\n/* start\ninside é 👩💻\nend */\nlet n = 42;\nlet text = \"unfinished",
|
||
),
|
||
("a.py", "text = '''first\ninside é\nlast'''\nanswer = 42"),
|
||
(
|
||
"a.js",
|
||
"const action = () => 42;\nfunction hello(require) {\n require('local');\n action;\n}\nrequire('global');\naction;",
|
||
),
|
||
(
|
||
"a.md",
|
||
"# Heading **bold**\n\n```rust\nfn main() {\n let n = 42;\n}\n```\n\n```python\ndef hello():\n return 7\n```\n\n```unknown\nfn plain() {}\n```",
|
||
),
|
||
(
|
||
"a.md",
|
||
"> # Heading **bold**\n>\n> ```rust\n> fn main() {\n> let n = 42;\n> }\n> ```",
|
||
),
|
||
(
|
||
"a.md",
|
||
"```html\n<script>\nfunction nested() {\n return 42;\n}\n</script>\n```",
|
||
),
|
||
(
|
||
"a.html",
|
||
"<div>é</div>\n<script>\nconst action = () => 42;\naction;\n</script>\n<style>\nbody { width: 7px; }\n</style>",
|
||
),
|
||
(
|
||
"a.js",
|
||
"const page = html`<div>${value}</div>\n<script>\nfunction inside() { return 42; }\n</script>`;",
|
||
),
|
||
];
|
||
for (path, original) in cases {
|
||
let mut visible = SyntaxCache::new();
|
||
for (revision, source) in [
|
||
original.to_owned(),
|
||
original.replace("42", "123"),
|
||
format!("\n{original}"),
|
||
original.replace("() => 42", "42"),
|
||
]
|
||
.iter()
|
||
.enumerate()
|
||
{
|
||
let input = lines(source);
|
||
let middle = input.len() / 2;
|
||
visible.update_visible(
|
||
&input,
|
||
Some(Path::new(path)),
|
||
revision as u64,
|
||
std::slice::from_ref(&(middle..middle + 1)),
|
||
);
|
||
let full = cache(source, path);
|
||
assert_eq!(visible.error(), None, "{path}");
|
||
assert_eq!(
|
||
visible.line(middle),
|
||
full.line(middle),
|
||
"{path} revision {revision}"
|
||
);
|
||
assert!(
|
||
visible
|
||
.lines
|
||
.iter()
|
||
.enumerate()
|
||
.all(|(row, spans)| row == middle || spans.is_empty())
|
||
);
|
||
let parses = visible.parse_counts();
|
||
let context = visible.context.as_ref().unwrap().captures.as_ptr();
|
||
// Unsorted, overlapping and out-of-bounds windows use original source rows.
|
||
for row in (0..input.len()).rev() {
|
||
visible.update_visible(
|
||
&input,
|
||
Some(Path::new(path)),
|
||
revision as u64,
|
||
&[
|
||
row..row + 1,
|
||
middle..middle + 1,
|
||
row..row + 1,
|
||
input.len()..usize::MAX,
|
||
],
|
||
);
|
||
assert_eq!(
|
||
visible.line(row),
|
||
full.line(row),
|
||
"{path} revision {revision} row {row}"
|
||
);
|
||
assert_eq!(
|
||
visible.parse_counts(),
|
||
parses,
|
||
"{path}: scrolling reparsed a tree"
|
||
);
|
||
assert_eq!(visible.context.as_ref().unwrap().captures.as_ptr(), context);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn visible_highlight_collection_stays_bounded_by_the_requested_rows() {
|
||
let mut input: Vec<_> = (0..1000)
|
||
.map(|row| format!("fn function_{row}() {{ let value = 42; }}"))
|
||
.collect();
|
||
let path = Path::new("large.rs");
|
||
let mut visible = SyntaxCache::new();
|
||
visible.update_visible(&input, Some(path), 0, std::slice::from_ref(&(500..502)));
|
||
assert_eq!(visible.parses, 1);
|
||
assert!(visible.captures.len() < 50);
|
||
assert!(visible.highlights.len() < 30);
|
||
assert!(visible.lines[..500].iter().all(Vec::is_empty));
|
||
assert!(visible.lines[502..].iter().all(Vec::is_empty));
|
||
input[500] = "fn changed() { let value = \"é 👩💻\"; }".to_owned();
|
||
visible.update_visible(&input, Some(path), 1, std::slice::from_ref(&(500..502)));
|
||
assert_eq!(visible.incremental_parses, 1);
|
||
assert!(visible.captures.len() < 50);
|
||
let mut full = SyntaxCache::new();
|
||
full.update(&input, Some(path), 1);
|
||
assert!(full.captures.len() > 1000);
|
||
for row in 500..502 {
|
||
assert_eq!(visible.line(row), full.line(row));
|
||
}
|
||
let parses = visible.parse_counts();
|
||
visible.update_visible(&input, Some(path), 1, std::slice::from_ref(&(950..952)));
|
||
assert_eq!(visible.parse_counts(), parses);
|
||
assert!(visible.captures.len() < 50);
|
||
for row in 950..952 {
|
||
assert_eq!(visible.line(row), full.line(row));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn visible_cache_supports_full_updates_and_same_revision_path_changes() {
|
||
let input = lines("const element = <div title=\"hi\" />;\nconst answer = 42;");
|
||
let mut visible = SyntaxCache::new();
|
||
visible.update_visible(
|
||
&input,
|
||
Some(Path::new("a.ts")),
|
||
0,
|
||
std::slice::from_ref(&(1..2)),
|
||
);
|
||
let parses = visible.parse_counts();
|
||
visible.update(&input, Some(Path::new("a.ts")), 0);
|
||
assert_eq!(visible.parse_counts(), parses);
|
||
assert_fresh(&visible, &input.join("\n"), "a.ts");
|
||
visible.update_visible(
|
||
&input,
|
||
Some(Path::new("a.tsx")),
|
||
0,
|
||
std::slice::from_ref(&(0..1)),
|
||
);
|
||
assert_eq!(visible.parses, parses.0 + 1);
|
||
assert_eq!(visible.line(0), cache(&input.join("\n"), "a.tsx").line(0));
|
||
assert!(visible.line(1).is_empty());
|
||
visible.update_text(&input.join("\n"), Path::new("a.tsx"));
|
||
assert_fresh(&visible, &input.join("\n"), "a.tsx");
|
||
visible.update_visible(
|
||
&input,
|
||
Some(Path::new("a.txt")),
|
||
0,
|
||
std::slice::from_ref(&(0..2)),
|
||
);
|
||
assert_eq!(visible.language(), None);
|
||
assert!(visible.lines.iter().all(Vec::is_empty));
|
||
}
|
||
|
||
fn cache(source: &str, path: &str) -> SyntaxCache {
|
||
let mut cache = SyntaxCache::new();
|
||
cache.update(&lines(source), Some(Path::new(path)), 0);
|
||
assert_eq!(cache.error(), None, "{path}");
|
||
cache
|
||
}
|
||
|
||
fn kind_at(cache: &SyntaxCache, row: usize, byte: usize) -> Option<SyntaxKind> {
|
||
cache
|
||
.line(row)
|
||
.iter()
|
||
.find_map(|span| (span.start_byte <= byte && byte < span.end_byte).then_some(span.kind))
|
||
}
|
||
|
||
fn assert_token(cache: &SyntaxCache, source: &str, row: usize, token: &str, kind: SyntaxKind) {
|
||
let line = source.split('\n').nth(row).unwrap();
|
||
let start = line.find(token).unwrap();
|
||
for (byte, _) in line[start..start + token.len()].char_indices() {
|
||
assert_eq!(
|
||
kind_at(cache, row, start + byte),
|
||
Some(kind),
|
||
"{token:?} in {}",
|
||
cache.language().unwrap()
|
||
);
|
||
}
|
||
}
|
||
|
||
fn assert_fresh(cache: &SyntaxCache, source: &str, path: &str) {
|
||
let fresh = self::cache(source, path);
|
||
assert_eq!(cache.language(), fresh.language());
|
||
assert_eq!(cache.error(), fresh.error());
|
||
assert_eq!(
|
||
cache.tree.as_ref().map(|tree| tree.root_node().to_sexp()),
|
||
fresh.tree.as_ref().map(|tree| tree.root_node().to_sexp())
|
||
);
|
||
let source = lines(source);
|
||
for (row, line) in source.iter().enumerate() {
|
||
assert_eq!(cache.line(row), fresh.line(row), "row {row}");
|
||
let mut previous = 0;
|
||
for span in cache.line(row) {
|
||
assert!(previous <= span.start_byte && span.start_byte < span.end_byte);
|
||
assert!(span.end_byte <= line.len());
|
||
assert!(line.is_char_boundary(span.start_byte) && line.is_char_boundary(span.end_byte));
|
||
previous = span.end_byte;
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn every_bundled_query_compiles_and_common_languages_color_real_tokens() {
|
||
for language in languages::all() {
|
||
configuration(language).unwrap_or_else(|error| panic!("{}: {error}", language.name));
|
||
}
|
||
let cases = [
|
||
(
|
||
"a.rs",
|
||
"Rust",
|
||
"fn main() { let x = 42; let s = \"hi\"; /* note */ }",
|
||
"fn",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.rb",
|
||
"Ruby",
|
||
"def hello\n 42\nend",
|
||
"def",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.py",
|
||
"Python",
|
||
"def hello():\n return 42",
|
||
"def",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.json",
|
||
"JSON",
|
||
"{\"n\":42,\"yes\":true}",
|
||
"42",
|
||
SyntaxKind::Number,
|
||
),
|
||
(
|
||
"a.sh",
|
||
"Bash",
|
||
"echo \"hi\" # note",
|
||
"hi",
|
||
SyntaxKind::String,
|
||
),
|
||
(
|
||
"Makefile",
|
||
"Makefile",
|
||
"# note\nall:\n\techo hi",
|
||
"note",
|
||
SyntaxKind::Comment,
|
||
),
|
||
(
|
||
"a.md",
|
||
"Markdown",
|
||
"# Heading\n\n**bold**",
|
||
"Heading",
|
||
SyntaxKind::Markup,
|
||
),
|
||
(
|
||
"a.js",
|
||
"JavaScript",
|
||
"function hello() { return 42; }",
|
||
"function",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.ts",
|
||
"TypeScript",
|
||
"function hello(): number { return 42; }",
|
||
"function",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.html",
|
||
"HTML",
|
||
"<div title=\"hi\">text</div>",
|
||
"div",
|
||
SyntaxKind::Markup,
|
||
),
|
||
(
|
||
"a.css",
|
||
"CSS",
|
||
"body { width: 42px; }",
|
||
"42",
|
||
SyntaxKind::Number,
|
||
),
|
||
(
|
||
"a.yaml",
|
||
"YAML",
|
||
"message: \"hi\"\ncount: 42",
|
||
"hi",
|
||
SyntaxKind::String,
|
||
),
|
||
(
|
||
"Cargo.toml",
|
||
"TOML",
|
||
"message = \"hi\"\ncount = 42",
|
||
"hi",
|
||
SyntaxKind::String,
|
||
),
|
||
(
|
||
"a.c",
|
||
"C",
|
||
"int main(void) { return 42; }",
|
||
"return",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.cpp",
|
||
"C++",
|
||
"int main() { return 42; }",
|
||
"return",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
(
|
||
"a.go",
|
||
"Go",
|
||
"package main\nfunc main() { return }",
|
||
"package",
|
||
SyntaxKind::Keyword,
|
||
),
|
||
];
|
||
for (path, language, source, token, kind) in cases {
|
||
let cache = self::cache(source, path);
|
||
assert_eq!(cache.language(), Some(language));
|
||
assert_token(&cache, source, 0, token, kind);
|
||
assert_fresh(&cache, source, path);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn semantic_colors_and_text_predicates_preserve_the_ui_contract() {
|
||
let source =
|
||
"fn main() { let n = 42; let f = 3.25; let b = true; let s = \"hello\"; /* note */ }";
|
||
let cache = self::cache(source, "a.rs");
|
||
for (token, kind) in [
|
||
("fn", SyntaxKind::Keyword),
|
||
("let", SyntaxKind::Keyword),
|
||
("main", SyntaxKind::Function),
|
||
("42", SyntaxKind::Number),
|
||
("3.25", SyntaxKind::Number),
|
||
("true", SyntaxKind::Keyword),
|
||
("hello", SyntaxKind::String),
|
||
("note", SyntaxKind::Comment),
|
||
] {
|
||
assert_token(&cache, source, 0, token, kind);
|
||
}
|
||
let source = "const foo = 42; const UPPER = 7; foo; UPPER;";
|
||
let cache = self::cache(source, "a.js");
|
||
assert_eq!(kind_at(&cache, 0, source.find("foo").unwrap()), None);
|
||
// JavaScript's bundled constant predicate must not color every identifier.
|
||
assert_ne!(
|
||
kind_at(&cache, 0, source.find("foo;").unwrap()),
|
||
Some(SyntaxKind::Keyword)
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn zig_highlights_literals_builtins_and_predicate_matched_identifiers() {
|
||
let source = r#"const std = @import("std");
|
||
const MAX_COUNT: u32 = 42;
|
||
pub fn main() void {
|
||
const local = @as(u32, 7);
|
||
const value = Point;
|
||
const text =
|
||
\\first é
|
||
\\second
|
||
;
|
||
// note
|
||
}"#;
|
||
let cache = self::cache(source, "main.zig");
|
||
for (row, token, kind) in [
|
||
(0, "const", SyntaxKind::Keyword),
|
||
(0, "@import", SyntaxKind::Keyword),
|
||
(0, "\"std\"", SyntaxKind::String),
|
||
(1, "MAX_COUNT", SyntaxKind::Keyword),
|
||
(1, "u32", SyntaxKind::Type),
|
||
(1, "42", SyntaxKind::Number),
|
||
(2, "pub", SyntaxKind::Keyword),
|
||
(2, "fn", SyntaxKind::Keyword),
|
||
(2, "main", SyntaxKind::Function),
|
||
(2, "void", SyntaxKind::Type),
|
||
(3, "@as", SyntaxKind::Function),
|
||
(4, "Point", SyntaxKind::Type),
|
||
(6, "first é", SyntaxKind::String),
|
||
(7, "second", SyntaxKind::String),
|
||
(9, "note", SyntaxKind::Comment),
|
||
] {
|
||
assert_token(&cache, source, row, token, kind);
|
||
}
|
||
let local = source.lines().nth(3).unwrap().find("local").unwrap();
|
||
assert_eq!(kind_at(&cache, 3, local), None);
|
||
}
|
||
|
||
#[test]
|
||
fn honey_highlights_declarations_literals_edits_and_markdown_fences() {
|
||
let source = "Point :: struct { x f64 }\n\
|
||
add proc(a, b i32) i32 {\n\
|
||
text := \"hello é\"\n\
|
||
enabled := true\n\
|
||
value := 42\n\
|
||
# note\n\
|
||
return a + b\n\
|
||
}";
|
||
let mut cache = self::cache(source, "main.hon");
|
||
assert_eq!(cache.language(), Some("Honey"));
|
||
assert!(!cache.tree.as_ref().unwrap().root_node().has_error());
|
||
for (row, token, kind) in [
|
||
(0, "Point", SyntaxKind::Type),
|
||
(0, "struct", SyntaxKind::Keyword),
|
||
(0, "f64", SyntaxKind::Type),
|
||
(1, "add", SyntaxKind::Function),
|
||
(1, "proc", SyntaxKind::Keyword),
|
||
(1, "i32", SyntaxKind::Type),
|
||
(2, "hello é", SyntaxKind::String),
|
||
(3, "true", SyntaxKind::Keyword),
|
||
(4, "42", SyntaxKind::Number),
|
||
(5, "note", SyntaxKind::Comment),
|
||
(6, "return", SyntaxKind::Keyword),
|
||
] {
|
||
assert_token(&cache, source, row, token, kind);
|
||
}
|
||
assert_eq!(kind_at(&cache, 6, 7), None);
|
||
let changed = source.replace("\"hello é\"", "7");
|
||
cache.update(&lines(&changed), Some(Path::new("main.hon")), 1);
|
||
assert_token(&cache, &changed, 2, "7", SyntaxKind::Number);
|
||
assert_fresh(&cache, &changed, "main.hon");
|
||
for tag in ["honey", "honeylang", "hon"] {
|
||
let markdown = format!("```{tag}\n{source}\n```");
|
||
let injected = self::cache(&markdown, "README.md");
|
||
assert_token(&injected, &markdown, 2, "add", SyntaxKind::Function);
|
||
assert_token(&injected, &markdown, 3, "hello é", SyntaxKind::String);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn typst_highlights_markup_code_edits_and_fenced_languages() {
|
||
let source = "= Heading\n#let message = \"hello é\"\n#let count = 42\n\
|
||
#text(message) // note\n*strong* and _emphasis_\n\
|
||
```rust\nfn main() { let n = 7; }\n```";
|
||
let mut cache = self::cache(source, "main.typ");
|
||
assert_eq!(cache.language(), Some("Typst"));
|
||
assert!(!cache.tree.as_ref().unwrap().root_node().has_error());
|
||
for (row, token, kind) in [
|
||
(0, "Heading", SyntaxKind::Markup),
|
||
(1, "let", SyntaxKind::Keyword),
|
||
(1, "hello é", SyntaxKind::String),
|
||
(2, "42", SyntaxKind::Number),
|
||
(3, "text", SyntaxKind::Function),
|
||
(3, "// note", SyntaxKind::Comment),
|
||
(4, "strong", SyntaxKind::Markup),
|
||
(4, "emphasis", SyntaxKind::Markup),
|
||
(6, "fn", SyntaxKind::Keyword),
|
||
(6, "7", SyntaxKind::Number),
|
||
] {
|
||
assert_token(&cache, source, row, token, kind);
|
||
}
|
||
let edited = source.replace("\"hello é\"", "false");
|
||
cache.update(&lines(&edited), Some(Path::new("main.typ")), 1);
|
||
assert_token(&cache, &edited, 1, "false", SyntaxKind::Keyword);
|
||
assert_fresh(&cache, &edited, "main.typ");
|
||
for tag in ["typst", "typ"] {
|
||
let markdown = format!("```{tag}\n#let count = 42\n```");
|
||
let injected = self::cache(&markdown, "README.md");
|
||
assert_token(&injected, &markdown, 1, "let", SyntaxKind::Keyword);
|
||
assert_token(&injected, &markdown, 1, "42", SyntaxKind::Number);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn filenames_shebang_save_as_and_tsx_use_actual_grammar_identity() {
|
||
let source = lines("\u{feff}#!/usr/bin/env python3\nreturn 42");
|
||
let mut cache = SyntaxCache::new();
|
||
cache.update(&source, None, 0);
|
||
assert_eq!(cache.language(), Some("Python"));
|
||
cache.update(&source, Some(Path::new("a.RS")), 0);
|
||
assert_eq!(cache.language(), Some("Rust"));
|
||
assert_eq!(cache.parses, 2);
|
||
cache.update(&source, Some(Path::new("renamed.rs")), 0);
|
||
assert_eq!(cache.parses, 2);
|
||
cache.update(&lines("all:\n\techo hi"), Some(Path::new("GNUmakefile")), 1);
|
||
assert_eq!(cache.language(), Some("Makefile"));
|
||
let source = "const element = <div title=\"hi\" />;";
|
||
cache.update(&lines(source), Some(Path::new("a.ts")), 2);
|
||
let typescript = cache.syntax.unwrap();
|
||
let parses = cache.parses;
|
||
cache.update(&lines(source), Some(Path::new("a.tsx")), 2);
|
||
assert_eq!(cache.language(), Some("TypeScript"));
|
||
assert!(!std::ptr::eq(typescript, cache.syntax.unwrap()));
|
||
assert_eq!(cache.parses, parses + 1);
|
||
assert_token(&cache, source, 0, "div", SyntaxKind::Markup);
|
||
assert_fresh(&cache, source, "a.tsx");
|
||
let mut script = SyntaxCache::new();
|
||
script.update(&lines("#!/usr/bin/env python3\nreturn 42"), None, 0);
|
||
assert_eq!(script.language(), Some("Python"));
|
||
script.update(&lines("#!/usr/bin/env bash\necho \"hi\""), None, 1);
|
||
assert_eq!(script.language(), Some("Bash"));
|
||
assert_token(
|
||
&script,
|
||
"#!/usr/bin/env bash\necho \"hi\"",
|
||
1,
|
||
"hi",
|
||
SyntaxKind::String,
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn unknown_and_former_non_common_languages_are_honest_plain_text() {
|
||
for path in [
|
||
"a.unknown",
|
||
"a.txt",
|
||
"a.hs",
|
||
"a.java",
|
||
"a.php",
|
||
"a.swift",
|
||
"a.sql",
|
||
] {
|
||
let cache = self::cache("fn main() { \"hi\"; 42; }", path);
|
||
assert_eq!(cache.language(), None, "{path}");
|
||
assert!(cache.lines.iter().all(Vec::is_empty));
|
||
assert_eq!(cache.parses, 0);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn unchanged_revision_and_same_source_do_not_allocate_or_parse() {
|
||
let mut cache = self::cache("fn main() {}\n", "a.rs");
|
||
let source = lines("fn main() {}\n");
|
||
let source_pointer = cache.source.as_ptr();
|
||
let scratch_pointer = cache.next_source.as_ptr();
|
||
let tree_id = cache.tree.as_ref().unwrap().root_node().id();
|
||
cache.update(&source, Some(Path::new("a.rs")), 0);
|
||
assert_eq!(cache.source.as_ptr(), source_pointer);
|
||
assert_eq!(cache.next_source.as_ptr(), scratch_pointer);
|
||
assert_eq!(cache.tree.as_ref().unwrap().root_node().id(), tree_id);
|
||
cache.update(&source, Some(Path::new("a.rs")), 1);
|
||
cache.update(&source, Some(Path::new("b.rs")), 1);
|
||
assert_eq!(cache.parses, 1);
|
||
assert_eq!(cache.incremental_parses, 0);
|
||
assert_eq!(cache.tree.as_ref().unwrap().root_node().id(), tree_id);
|
||
assert!(cache.line(1).is_empty());
|
||
cache.update(&source, Some(Path::new("b.txt")), 1);
|
||
assert_eq!(cache.language(), None);
|
||
assert!(cache.tree.is_none());
|
||
assert!(cache.lines.iter().all(Vec::is_empty));
|
||
cache.update(&source, Some(Path::new("b.rs")), 1);
|
||
assert_eq!(cache.parses, 2);
|
||
assert_eq!(cache.incremental_parses, 0);
|
||
}
|
||
|
||
fn assert_plain_text_storage(cache: &SyntaxCache) {
|
||
assert!(cache.tree.is_none());
|
||
assert!(cache.context.is_none());
|
||
assert!(cache.scopes.get().is_none());
|
||
assert_eq!(cache.source.capacity(), 0);
|
||
assert_eq!(cache.next_source.capacity(), 0);
|
||
assert_eq!(cache.line_starts.capacity(), 0);
|
||
assert_eq!(cache.lines.capacity(), 0);
|
||
assert_eq!(cache.string_spans.capacity(), 0);
|
||
assert_eq!(cache.highlighted.capacity(), 0);
|
||
assert_eq!(cache.injections.capacity(), 0);
|
||
assert_eq!(cache.captures.capacity(), 0);
|
||
assert_eq!(cache.highlights.capacity(), 0);
|
||
assert_eq!(cache.events.capacity(), 0);
|
||
assert!(cache.line(0).is_empty());
|
||
assert!(cache.string_spans(0).is_empty());
|
||
assert!(cache.scope_at(0).is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn syntax_budget_crossing_releases_state_and_reenables_after_shrinking() {
|
||
let small = "fn main() { let value = \"ok\"; }";
|
||
let mut input = lines(small);
|
||
let mut remaining = MAX_SYNTAX_BYTES - small.len();
|
||
while remaining > 0 {
|
||
let length = (remaining - 1).min(16 * 1024);
|
||
input.push(" ".repeat(length));
|
||
remaining -= length + 1;
|
||
}
|
||
let path = Some(Path::new("budget.rs"));
|
||
let mut cache = SyntaxCache::new();
|
||
cache.update_visible(&input, path, 0, std::slice::from_ref(&(0..1)));
|
||
assert_eq!(cache.source.len(), MAX_SYNTAX_BYTES);
|
||
assert_eq!(cache.error(), None);
|
||
assert_eq!(cache.parses, 1);
|
||
assert_token(&cache, small, 0, "fn", SyntaxKind::Keyword);
|
||
assert!(cache.scope_at(0).is_some());
|
||
input.last_mut().unwrap().push(' ');
|
||
cache.update_visible(&input, path, 1, std::slice::from_ref(&(0..1)));
|
||
assert_eq!(cache.language(), Some("Rust"));
|
||
assert!(cache.error().unwrap().contains("plain text"));
|
||
assert_eq!(cache.parses, 1);
|
||
assert_plain_text_storage(&cache);
|
||
let notice = cache.error.as_ref().unwrap().as_ptr();
|
||
cache.update(&input, path, 1);
|
||
assert_eq!(cache.error.as_ref().unwrap().as_ptr(), notice);
|
||
assert_eq!(cache.parses, 1);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update(&input, Some(Path::new("budget.py")), 1);
|
||
assert_eq!(cache.language(), Some("Python"));
|
||
assert!(cache.error().unwrap().starts_with("Python"));
|
||
assert_plain_text_storage(&cache);
|
||
cache.update(&input, Some(Path::new("budget.txt")), 1);
|
||
assert_eq!(cache.language(), None);
|
||
assert_eq!(cache.error(), None);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update(&lines(small), path, 2);
|
||
assert_eq!(cache.parses, 2);
|
||
assert_eq!(cache.error(), None);
|
||
assert_token(&cache, small, 0, "fn", SyntaxKind::Keyword);
|
||
assert!(cache.scope_at(0).is_some());
|
||
}
|
||
|
||
#[test]
|
||
fn diff_syntax_budget_counts_the_separate_final_newline() {
|
||
let mut input = vec!["//".to_owned() + &" ".repeat(16 * 1024 - 2); 63];
|
||
input.push("//".to_owned() + &" ".repeat(16 * 1024 - 65));
|
||
let path = Some(Path::new("budget.rs"));
|
||
let mut cache = SyntaxCache::new();
|
||
cache.update_diff(&input, path, 0, false, None);
|
||
assert_eq!(cache.source.len(), MAX_SYNTAX_BYTES);
|
||
assert_eq!(cache.parses, 1);
|
||
assert_eq!(kind_at(&cache, 0, 0), Some(SyntaxKind::Comment));
|
||
cache.update_diff(&input, path, 0, true, None);
|
||
assert_eq!(cache.parses, 1);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update_diff(&input, path, 0, false, Some(std::slice::from_ref(&(0..1))));
|
||
assert_eq!(cache.parses, 2);
|
||
assert_eq!(cache.error(), None);
|
||
assert_eq!(kind_at(&cache, 0, 0), Some(SyntaxKind::Comment));
|
||
}
|
||
|
||
#[test]
|
||
fn long_lines_and_large_text_never_copy_or_parse_and_clear_injections() {
|
||
let markdown = "# Title\n```rust\nfn main() { \"ok\"; }\n```";
|
||
let mut cache = self::cache(markdown, "hover.md");
|
||
assert!(!cache.injections.is_empty());
|
||
assert!(cache.scope_at(2).is_some());
|
||
let parses = cache.parse_counts();
|
||
let long_line = "//".to_owned() + &" ".repeat(MAX_SYNTAX_LINE_BYTES - 1);
|
||
cache.update_text(&long_line, Path::new("large.rs"));
|
||
assert_eq!(cache.language(), Some("Rust"));
|
||
assert_eq!(cache.parse_counts(), parses);
|
||
assert!(cache.error().unwrap().contains("line"));
|
||
assert_plain_text_storage(&cache);
|
||
let large = " ".repeat(52 * 1024 * 1024);
|
||
cache.update_text(&large, Path::new("parser.c"));
|
||
assert_eq!(cache.language(), Some("C"));
|
||
assert_eq!(cache.parse_counts(), parses);
|
||
assert_plain_text_storage(&cache);
|
||
let notice = cache.error.as_ref().unwrap().as_ptr();
|
||
cache.update_text(&large, Path::new("parser.c"));
|
||
assert_eq!(cache.error.as_ref().unwrap().as_ptr(), notice);
|
||
assert_plain_text_storage(&cache);
|
||
let large_lines = vec![large];
|
||
cache.update(&large_lines, Some(Path::new("parser.c")), 10);
|
||
assert_eq!(cache.language(), Some("C"));
|
||
assert_eq!(cache.parse_counts(), parses);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update_diff(&large_lines, Some(Path::new("parser.c")), 10, true, None);
|
||
assert_eq!(cache.parse_counts(), parses);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update_text(markdown, Path::new("hover.md"));
|
||
assert!(cache.parse_counts().0 > parses.0);
|
||
assert_eq!(cache.error(), None);
|
||
assert!(!cache.injections.is_empty());
|
||
assert!(cache.scope_at(2).is_some());
|
||
let boundary = "//".to_owned() + &" ".repeat(MAX_SYNTAX_LINE_BYTES - 2);
|
||
cache.update(&lines(&boundary), Some(Path::new("line.rs")), 50);
|
||
assert_eq!(cache.error(), None);
|
||
assert_eq!(kind_at(&cache, 0, 0), Some(SyntaxKind::Comment));
|
||
cache.update(&lines(&long_line), Some(Path::new("line.rs")), 51);
|
||
assert_plain_text_storage(&cache);
|
||
cache.update_text("", Path::new("line.rs"));
|
||
assert_eq!(cache.language(), Some("Rust"));
|
||
assert_eq!(cache.error(), None);
|
||
assert!(cache.budget_exceeded.is_none());
|
||
assert!(cache.line(0).is_empty());
|
||
assert!(cache.scope_at(0).is_none());
|
||
|
||
let mut script = vec!["#!/usr/bin/env python3".to_owned(), long_line.clone()];
|
||
cache.update(&script, None, 60);
|
||
assert_eq!(cache.language(), Some("Python"));
|
||
assert_plain_text_storage(&cache);
|
||
script[0] = "#!/usr/bin/env ruby".to_owned();
|
||
cache.update(&script, None, 61);
|
||
assert_eq!(cache.language(), Some("Ruby"));
|
||
assert!(cache.error().unwrap().starts_with("Ruby"));
|
||
assert_plain_text_storage(&cache);
|
||
script.pop();
|
||
cache.update(&script, None, 62);
|
||
assert_eq!(cache.language(), Some("Ruby"));
|
||
assert_eq!(cache.error(), None);
|
||
assert!(cache.tree.is_some());
|
||
}
|
||
|
||
#[test]
|
||
fn unicode_minimal_edits_use_byte_points_and_never_split_codepoints() {
|
||
let old = "x\n\t\"é 👩💻\"\n";
|
||
let new = "x\n\t\"ê 👩💻\"\n";
|
||
let edit = minimal_edit(old, new);
|
||
assert_eq!(edit.start_byte, 4);
|
||
assert_eq!(edit.start_position, Point::new(1, 2));
|
||
assert_eq!(edit.old_end_byte, 6);
|
||
assert_eq!(edit.new_end_byte, 6);
|
||
assert_eq!(edit.old_end_position, Point::new(1, 4));
|
||
let edit = minimal_edit("a\nβ\n", "a\n\nβ\n");
|
||
assert_eq!(edit.start_position, Point::new(1, 0));
|
||
assert_eq!(edit.old_end_position, Point::new(1, 0));
|
||
assert_eq!(edit.new_end_position, Point::new(2, 0));
|
||
let edit = minimal_edit("α", "");
|
||
assert_eq!(
|
||
(edit.start_byte, edit.old_end_byte, edit.new_end_byte),
|
||
(0, 2, 0)
|
||
);
|
||
let edit = minimal_edit("xα", "xѱ");
|
||
assert_eq!(
|
||
(edit.start_byte, edit.old_end_byte, edit.new_end_byte),
|
||
(1, 3, 3)
|
||
);
|
||
assert_eq!(edit.new_end_position, Point::new(0, 3));
|
||
}
|
||
|
||
#[test]
|
||
fn incremental_unicode_newline_insert_remove_and_undo_match_fresh_trees() {
|
||
let original = "fn main() {\n\tlet text = \"é é 👩💻\";\n\t/* nested /* inner */ note */\n}\n";
|
||
let mut cache = self::cache(original, "a.rs");
|
||
let edits = [
|
||
original.replace("é", "ê"),
|
||
original.replace("let text", "\nlet text"),
|
||
original.replace("\n\t/* nested /* inner */ note */", ""),
|
||
original.replace("👩💻", "👩🚀"),
|
||
original.replace("\";", "\";\n\tlet n = 42;"),
|
||
original.to_owned(),
|
||
String::new(),
|
||
original.to_owned(),
|
||
];
|
||
for (revision, source) in edits.iter().enumerate() {
|
||
cache.update(&lines(source), Some(Path::new("a.rs")), revision as u64 + 1);
|
||
assert_fresh(&cache, source, "a.rs");
|
||
}
|
||
assert_eq!(cache.parses, edits.len() + 1);
|
||
assert_eq!(cache.incremental_parses, edits.len());
|
||
}
|
||
|
||
#[test]
|
||
fn unfinished_source_and_multiline_offscreen_state_remain_highlighted() {
|
||
let source = "fn main() {\n/* start\ninside 👩💻\nend */\nlet n = 42;\nlet text = \"unfinished";
|
||
let cache = self::cache(source, "a.rs");
|
||
assert!(cache.tree.as_ref().unwrap().root_node().has_error());
|
||
assert_token(&cache, source, 0, "fn", SyntaxKind::Keyword);
|
||
assert_token(&cache, source, 2, "inside", SyntaxKind::Comment);
|
||
assert_token(&cache, source, 4, "42", SyntaxKind::Number);
|
||
assert_eq!(cache.error(), None);
|
||
let source = "text = '''first\ninside\nlast'''\nanswer = 42";
|
||
let cache = self::cache(source, "a.py");
|
||
assert_token(&cache, source, 1, "inside", SyntaxKind::String);
|
||
assert_token(&cache, source, 3, "42", SyntaxKind::Number);
|
||
}
|
||
|
||
#[test]
|
||
fn markdown_heading_markers_share_title_colors_without_coloring_plain_hashes() {
|
||
let source = "# One\n## Two\n### Three\n#### Four\n##### Five\n###### Six\n\nSetext\n======\n\nplain # text";
|
||
let cache = self::cache(source, "headings.md");
|
||
for row in 0..6 {
|
||
assert_token(
|
||
&cache,
|
||
source,
|
||
row,
|
||
&"#".repeat(row + 1),
|
||
SyntaxKind::Markup,
|
||
);
|
||
}
|
||
assert_token(&cache, source, 0, "One", SyntaxKind::Markup);
|
||
assert_token(&cache, source, 7, "Setext", SyntaxKind::Markup);
|
||
assert_token(&cache, source, 8, "======", SyntaxKind::Markup);
|
||
assert_eq!(kind_at(&cache, 10, 6), None);
|
||
}
|
||
|
||
#[test]
|
||
fn markdown_list_markers_color_bullets_and_numbers_without_coloring_plain_text() {
|
||
let source = "- item\n - nested\n 12. ordered\n\n+ item\n\n* item\n\n1. ordered\n2. next\n\n3) ordered\n\n> - quoted\n> 4. ordered\n\nplain - text and 1. text\n\n\\- escaped";
|
||
let mut cache = self::cache(source, "lists.md");
|
||
for (row, marker) in [
|
||
(0, "-"),
|
||
(1, "-"),
|
||
(2, "12."),
|
||
(4, "+"),
|
||
(6, "*"),
|
||
(8, "1."),
|
||
(9, "2."),
|
||
(11, "3)"),
|
||
(13, "-"),
|
||
(14, "4."),
|
||
] {
|
||
assert_token(&cache, source, row, marker, SyntaxKind::Markup);
|
||
}
|
||
assert_eq!(kind_at(&cache, 0, 2), None);
|
||
assert_eq!(kind_at(&cache, 16, 6), None);
|
||
assert_eq!(kind_at(&cache, 16, 17), None);
|
||
assert_ne!(kind_at(&cache, 18, 1), Some(SyntaxKind::Markup));
|
||
|
||
let edited = source.replacen("- item", "plain - item", 1);
|
||
cache.update(&lines(&edited), Some(Path::new("lists.md")), 1);
|
||
assert_eq!(kind_at(&cache, 0, 6), None);
|
||
assert_fresh(&cache, &edited, "lists.md");
|
||
}
|
||
|
||
#[test]
|
||
fn markdown_inline_and_fences_inject_known_languages_and_update_incrementally() {
|
||
let original = "A **bold** and `code` link.\n\n```rust\nfn main() { let n = 42; }\n```\n\n```python\ndef hello():\n return 7\n```\n\n```not-a-language\nfn not_rust() { 99; }\n```";
|
||
let mut cache = self::cache(original, "a.md");
|
||
assert_token(&cache, original, 0, "bold", SyntaxKind::Markup);
|
||
assert_token(&cache, original, 0, "code", SyntaxKind::Markup);
|
||
assert_token(&cache, original, 3, "fn", SyntaxKind::Keyword);
|
||
assert_token(&cache, original, 3, "main", SyntaxKind::Function);
|
||
assert_token(&cache, original, 3, "42", SyntaxKind::Number);
|
||
assert_token(&cache, original, 7, "def", SyntaxKind::Keyword);
|
||
assert_ne!(kind_at(&cache, 12, 0), Some(SyntaxKind::Keyword));
|
||
let parses = cache.injection_parses;
|
||
let source = original.replace("42", "123");
|
||
cache.update(&lines(&source), Some(Path::new("a.md")), 1);
|
||
assert_token(&cache, &source, 3, "123", SyntaxKind::Number);
|
||
assert_fresh(&cache, &source, "a.md");
|
||
assert!(cache.injection_parses > parses);
|
||
let source = source.replace("```rust", "```unknown");
|
||
cache.update(&lines(&source), Some(Path::new("a.md")), 2);
|
||
assert_ne!(kind_at(&cache, 3, 0), Some(SyntaxKind::Keyword));
|
||
assert_fresh(&cache, &source, "a.md");
|
||
}
|
||
|
||
#[test]
|
||
fn markdown_injections_keep_anonymous_syntax_but_not_named_block_continuations() {
|
||
let source = "> # Heading **bold**\n>\n> ```rust\n> fn main() {\n> let n = 3.25;\n> }\n> ```";
|
||
let cache = self::cache(source, "a.md");
|
||
assert_token(&cache, source, 0, "Heading", SyntaxKind::Markup);
|
||
assert_token(&cache, source, 0, "bold", SyntaxKind::Markup);
|
||
assert_token(&cache, source, 3, "main", SyntaxKind::Function);
|
||
assert_token(&cache, source, 4, "3.25", SyntaxKind::Number);
|
||
let rust = languages::by_name("rust").unwrap();
|
||
let layer = cache
|
||
.injections
|
||
.iter()
|
||
.find(|layer| std::ptr::eq(layer.syntax, rust))
|
||
.unwrap();
|
||
for range in &layer.ranges {
|
||
assert!(!source[range.start_byte..range.end_byte].contains('>'));
|
||
}
|
||
let braces = [source.find('{').unwrap(), source.find('}').unwrap()];
|
||
for byte in braces {
|
||
assert!(
|
||
layer
|
||
.ranges
|
||
.iter()
|
||
.any(|range| range.start_byte <= byte && byte < range.end_byte)
|
||
);
|
||
}
|
||
assert_fresh(&cache, source, "a.md");
|
||
}
|
||
|
||
#[test]
|
||
fn html_script_style_injections_override_host_and_reuse_unchanged_trees() {
|
||
let original = "<div>hello</div>\n<script>function hello() { return 42; }</script>\n<style>body { color: red; width: 7px; }</style>";
|
||
let mut cache = self::cache(original, "a.html");
|
||
assert_token(&cache, original, 0, "div", SyntaxKind::Markup);
|
||
assert_token(&cache, original, 1, "function", SyntaxKind::Keyword);
|
||
assert_token(&cache, original, 1, "hello", SyntaxKind::Function);
|
||
assert_token(&cache, original, 1, "42", SyntaxKind::Number);
|
||
assert_token(&cache, original, 2, "7", SyntaxKind::Number);
|
||
let injection_parses = cache.injection_parses;
|
||
let source = original.replace("<div>hello", "<div>world");
|
||
cache.update(&lines(&source), Some(Path::new("a.html")), 1);
|
||
assert_eq!(cache.injection_parses, injection_parses);
|
||
assert_fresh(&cache, &source, "a.html");
|
||
let source = source.replace("42", "123");
|
||
cache.update(&lines(&source), Some(Path::new("a.html")), 2);
|
||
assert_token(&cache, &source, 1, "123", SyntaxKind::Number);
|
||
assert_fresh(&cache, &source, "a.html");
|
||
// Inserting at an included range's exact end must reparse, not merely edit its old tree.
|
||
let source = source.replace("return 123; }", "return 123; } function added() {}");
|
||
cache.update(&lines(&source), Some(Path::new("a.html")), 3);
|
||
assert_token(&cache, &source, 1, "added", SyntaxKind::Function);
|
||
assert_fresh(&cache, &source, "a.html");
|
||
}
|
||
|
||
#[test]
|
||
fn local_definitions_disable_builtin_captures_and_propagate_highlights() {
|
||
let source = "function hello(require) { require('local'); }\nrequire('global');";
|
||
let cache = self::cache(source, "a.js");
|
||
let local = source.find("require('local')").unwrap();
|
||
assert_eq!(kind_at(&cache, 0, local), None);
|
||
assert_token(&cache, source, 1, "require", SyntaxKind::Function);
|
||
let source = "const action = () => 42;\naction;";
|
||
let cache = self::cache(source, "a.js");
|
||
assert_token(&cache, source, 0, "action", SyntaxKind::Function);
|
||
assert_token(&cache, source, 1, "action", SyntaxKind::Function);
|
||
}
|
||
|
||
#[test]
|
||
fn overlapping_capture_specificity_priority_and_plain_injection_are_nonoverlapping() {
|
||
let source = "αβγ";
|
||
let mut spans = vec![Vec::new()];
|
||
let mut events = Vec::new();
|
||
let highlights = vec![
|
||
Highlight {
|
||
start: 0,
|
||
end: 6,
|
||
kind: Some(SyntaxKind::String),
|
||
depth: 0,
|
||
priority: 0,
|
||
pattern: 99,
|
||
},
|
||
Highlight {
|
||
start: 2,
|
||
end: 4,
|
||
kind: Some(SyntaxKind::Function),
|
||
depth: 0,
|
||
priority: 0,
|
||
pattern: 1,
|
||
},
|
||
Highlight {
|
||
start: 4,
|
||
end: 6,
|
||
kind: None,
|
||
depth: 1,
|
||
priority: i32::MIN,
|
||
pattern: 0,
|
||
},
|
||
Highlight {
|
||
start: 0,
|
||
end: 2,
|
||
kind: Some(SyntaxKind::Keyword),
|
||
depth: 0,
|
||
priority: 10,
|
||
pattern: 0,
|
||
},
|
||
];
|
||
render_spans(
|
||
source,
|
||
&[0],
|
||
&mut spans,
|
||
&mut vec![Vec::new(); 1],
|
||
&highlights,
|
||
&mut events,
|
||
&[source_range(source)],
|
||
);
|
||
assert_eq!(
|
||
spans[0],
|
||
vec![
|
||
SyntaxSpan {
|
||
start_byte: 0,
|
||
end_byte: 2,
|
||
kind: SyntaxKind::Keyword
|
||
},
|
||
SyntaxSpan {
|
||
start_byte: 2,
|
||
end_byte: 4,
|
||
kind: SyntaxKind::Function
|
||
},
|
||
]
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn local_initializer_visibility_positive_predicates_and_noninheriting_scopes() {
|
||
let syntax = languages::by_name("javascript").unwrap();
|
||
let locals = r#"
|
||
(program) @local.scope
|
||
((function_declaration) @local.scope (#set! local.scope-inherits false))
|
||
(variable_declarator name: (identifier) @local.definition value: (_) @local.definition-value)
|
||
(identifier) @local.reference
|
||
"#;
|
||
let source_query = format!(
|
||
"{locals}\n{}",
|
||
r#"
|
||
((identifier) @function (#is-not? local))
|
||
((identifier) @string (#is? local))
|
||
(variable_declarator name: (identifier) @type)
|
||
"#
|
||
);
|
||
let query = Query::new(&syntax.language, &source_query).unwrap();
|
||
let highlights_start = (0..query.pattern_count())
|
||
.filter(|pattern| query.start_byte_for_pattern(*pattern) < locals.len() + 1)
|
||
.count();
|
||
let configuration = Configuration::new(syntax, query, 0, highlights_start);
|
||
let source = "const value = value;\nvalue;\nfunction inner() { value; }";
|
||
let cache = self::cache(source, "a.js");
|
||
let mut highlights = Vec::new();
|
||
collect_layer(
|
||
&configuration,
|
||
cache.tree.as_ref().unwrap(),
|
||
source,
|
||
&[source_range(source)],
|
||
&[source_range(source)],
|
||
&mut None,
|
||
0,
|
||
None,
|
||
&mut QueryCursor::new(),
|
||
&mut Vec::new(),
|
||
&mut highlights,
|
||
)
|
||
.unwrap();
|
||
let mut spans = vec![Vec::new(); 3];
|
||
let starts = [
|
||
0,
|
||
source.find("\nvalue;").unwrap() + 1,
|
||
source.find("\nfunction").unwrap() + 1,
|
||
];
|
||
render_spans(
|
||
source,
|
||
&starts,
|
||
&mut spans,
|
||
&mut vec![Vec::new(); 3],
|
||
&highlights,
|
||
&mut Vec::new(),
|
||
&[source_range(source)],
|
||
);
|
||
let kind = |row: usize, byte: usize| {
|
||
spans[row]
|
||
.iter()
|
||
.find_map(|span| (span.start_byte <= byte && byte < span.end_byte).then_some(span.kind))
|
||
};
|
||
assert_eq!(kind(0, 6), Some(SyntaxKind::Type));
|
||
assert_eq!(kind(0, 14), Some(SyntaxKind::Function));
|
||
assert_eq!(kind(1, 0), Some(SyntaxKind::Type));
|
||
assert_eq!(kind(2, 19), Some(SyntaxKind::Function));
|
||
let mut context = None;
|
||
for row in [1, 2] {
|
||
let window = [Range {
|
||
start_byte: starts[row],
|
||
end_byte: starts.get(row + 1).copied().unwrap_or(source.len()),
|
||
start_point: Point::new(row, 0),
|
||
end_point: point_at(source, starts.get(row + 1).copied().unwrap_or(source.len())),
|
||
}];
|
||
let mut visible_highlights = Vec::new();
|
||
collect_layer(
|
||
&configuration,
|
||
cache.tree.as_ref().unwrap(),
|
||
source,
|
||
&[source_range(source)],
|
||
&window,
|
||
&mut context,
|
||
0,
|
||
None,
|
||
&mut QueryCursor::new(),
|
||
&mut Vec::new(),
|
||
&mut visible_highlights,
|
||
)
|
||
.unwrap();
|
||
let mut visible_spans = vec![Vec::new(); 3];
|
||
render_spans(
|
||
source,
|
||
&starts,
|
||
&mut visible_spans,
|
||
&mut vec![Vec::new(); 3],
|
||
&visible_highlights,
|
||
&mut Vec::new(),
|
||
&window,
|
||
);
|
||
assert_eq!(visible_spans[row], spans[row]);
|
||
assert!(
|
||
visible_spans
|
||
.iter()
|
||
.enumerate()
|
||
.all(|(other, spans)| other == row || spans.is_empty())
|
||
);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn grammar_and_unsupported_predicate_errors_are_not_silent_empty_queries() {
|
||
static INVALID: LazyLock<[LanguageSpec; 2]> = LazyLock::new(|| {
|
||
let language = languages::by_name("rust").unwrap();
|
||
[
|
||
"(not_a_rust_node) @keyword",
|
||
"((identifier) @function (#unsupported? @function))",
|
||
]
|
||
.map(|query| LanguageSpec {
|
||
id: language.id,
|
||
name: "invalid test grammar query",
|
||
language: language.language.clone(),
|
||
highlights: query,
|
||
injections: "",
|
||
locals: "",
|
||
})
|
||
});
|
||
for syntax in INVALID.iter() {
|
||
assert!(compile_configuration(syntax).is_err());
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn combined_tagged_templates_and_nested_markdown_html_keep_real_injections() {
|
||
let source =
|
||
"const page = html`<div>${value}</div><script>function inside() { return 42; }</script>`;";
|
||
let cache = self::cache(source, "a.js");
|
||
assert_token(&cache, source, 0, "div", SyntaxKind::Markup);
|
||
assert_token(&cache, source, 0, "inside", SyntaxKind::Function);
|
||
assert_token(&cache, source, 0, "42", SyntaxKind::Number);
|
||
assert_fresh(&cache, source, "a.js");
|
||
let source = "```html\n<script>function nested() { return 7; }</script>\n```";
|
||
let cache = self::cache(source, "a.md");
|
||
assert_token(&cache, source, 1, "nested", SyntaxKind::Function);
|
||
assert_token(&cache, source, 1, "7", SyntaxKind::Number);
|
||
assert_fresh(&cache, source, "a.md");
|
||
let source = "fn main() { println!(\"{}\", 42); }";
|
||
let cache = self::cache(source, "a.rs");
|
||
assert_token(&cache, source, 0, "42", SyntaxKind::Number);
|
||
assert!(cache.injections.len() <= 16);
|
||
assert_fresh(&cache, source, "a.rs");
|
||
}
|
||
|
||
#[test]
|
||
fn parser_state_is_isolated_between_buffers() {
|
||
let mut first = self::cache("/* open\ninside", "a.rs");
|
||
let second = self::cache("fn main() { let n = 42; }", "b.rs");
|
||
first.update(
|
||
&lines("/* open */\nfn other() {}"),
|
||
Some(Path::new("a.rs")),
|
||
1,
|
||
);
|
||
assert_token(
|
||
&second,
|
||
"fn main() { let n = 42; }",
|
||
0,
|
||
"fn",
|
||
SyntaxKind::Keyword,
|
||
);
|
||
assert_eq!(second.parses, 1);
|
||
assert_eq!(first.incremental_parses, 1);
|
||
}
|