Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

64.8 KB
Raw Blame
use super::*;
use crate::{
    LanguageConfig, LanguageMatcher, LanguageName, LanguageQueries,
    buffer_tests::markdown_inline_lang, markdown_lang, rust_lang,
};
use gpui::App;
use indoc::indoc;
use pretty_assertions::assert_eq;
use rand::rngs::StdRng;
use std::borrow::Cow;
use std::{env, ops::Range, sync::Arc};
use text::{Buffer, BufferId, ReplicaId};
use tree_sitter::Node;
use unindent::Unindent as _;
use util::test::marked_text_ranges;

#[test]
fn test_parse_text_inside_multibyte_character() -> anyhow::Result<()> {
    let language = rust_lang();
    let grammar = language.grammar().expect("Rust grammar");
    for prefix in ["", "prefix "] {
        for character in ["и", "中", "🧘"] {
            let source = format!("// {character}\nfn main() {{}}");
            let text = Rope::from(format!("{prefix}{source}").as_str());
            for character_offset in 1..character.len() {
                let range = tree_sitter::Range {
                    start_byte: 3 + character_offset,
                    start_point: tree_sitter::Point {
                        row: 0,
                        column: 3 + character_offset,
                    },
                    end_byte: source.len(),
                    end_point: text.max_point().to_ts_point(),
                };
                let tree = parse_text(grammar, &text, prefix.len(), &[range], None, &mut None)?;

                let mut parser = tree_sitter::Parser::new();
                parser.set_language(&grammar.ts_language)?;
                parser.set_included_ranges(&[range])?;
                let expected_tree = parser
                    .parse(source.as_bytes(), None)
                    .expect("parse contiguous bytes");
                assert_eq!(
                    tree.root_node().to_sexp(),
                    expected_tree.root_node().to_sexp()
                );
                assert_eq!(
                    tree.root_node().byte_range(),
                    expected_tree.root_node().byte_range()
                );
                assert_eq!(tree.root_node().end_byte(), source.len());
            }
        }
    }
    Ok(())
}

#[test]
fn test_query_text_inside_multibyte_character() -> anyhow::Result<()> {
    let language = rust_lang();
    let grammar = language.grammar().expect("Rust grammar");
    let query = Query::new(
        &grammar.ts_language,
        "((ERROR) @error (#match? @error \".*\"))",
    )?;
    for character in ["и", "中", "🧘"] {
        let source = format!("// {character}\nfn main() {{}}");
        let text = Rope::from(source.as_str());
        for character_offset in 1..character.len() {
            let range = tree_sitter::Range {
                start_byte: 3 + character_offset,
                start_point: tree_sitter::Point {
                    row: 0,
                    column: 3 + character_offset,
                },
                end_byte: text.len(),
                end_point: text.max_point().to_ts_point(),
            };
            let tree = parse_text(grammar, &text, 0, &[range], None, &mut None)?;
            let mut cursor = QueryCursor::new();
            let mut matches = cursor.matches(&query, tree.root_node(), TextProvider(&text));
            let query_match = matches.next().expect("predicate matches the error node");
            let node = query_match.captures().first().expect("error capture").node;
            assert_eq!(node.start_byte(), range.start_byte);
            assert!(!source.is_char_boundary(node.start_byte()));
            assert_eq!(
                tree_sitter::TextProvider::text(&mut TextProvider(&text), node)
                    .flatten()
                    .copied()
                    .collect::<Vec<_>>(),
                &source.as_bytes()[node.byte_range()],
            );
        }
    }
    Ok(())
}

#[test]
fn test_splice_included_ranges() {
    let ranges = vec![ts_range(20..30), ts_range(50..60), ts_range(80..90)];

    let (new_ranges, change) = splice_included_ranges(
        ranges.clone(),
        &[54..56, 58..68],
        &[ts_range(50..54), ts_range(59..67)],
    );
    assert_eq!(
        new_ranges,
        &[
            ts_range(20..30),
            ts_range(50..54),
            ts_range(59..67),
            ts_range(80..90),
        ]
    );
    assert_eq!(change, 1..3);

    let (new_ranges, change) = splice_included_ranges(ranges.clone(), &[70..71, 91..100], &[]);
    assert_eq!(
        new_ranges,
        &[ts_range(20..30), ts_range(50..60), ts_range(80..90)]
    );
    assert_eq!(change, 2..3);

    let (new_ranges, change) =
        splice_included_ranges(ranges.clone(), &[], &[ts_range(0..2), ts_range(70..75)]);
    assert_eq!(
        new_ranges,
        &[
            ts_range(0..2),
            ts_range(20..30),
            ts_range(50..60),
            ts_range(70..75),
            ts_range(80..90)
        ]
    );
    assert_eq!(change, 0..4);

    let (new_ranges, change) =
        splice_included_ranges(ranges.clone(), &[30..50], &[ts_range(25..55)]);
    assert_eq!(new_ranges, &[ts_range(25..55), ts_range(80..90)]);
    assert_eq!(change, 0..1);

    // does not create overlapping ranges
    let (new_ranges, change) = splice_included_ranges(ranges, &[0..18], &[ts_range(20..32)]);
    assert_eq!(
        new_ranges,
        &[ts_range(20..32), ts_range(50..60), ts_range(80..90)]
    );
    assert_eq!(change, 0..1);

    fn ts_range(range: Range<usize>) -> tree_sitter::Range {
        tree_sitter::Range {
            start_byte: range.start,
            start_point: tree_sitter::Point {
                row: 0,
                column: range.start,
            },
            end_byte: range.end,
            end_point: tree_sitter::Point {
                row: 0,
                column: range.end,
            },
        }
    }
}

#[gpui::test]
fn test_syntax_map_layers_for_range(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = rust_lang();
    registry.add(language.clone());

    let mut buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r#"
            fn a() {
                assert_eq!(
                    b(vec![C {}]),
                    vec![d.e],
                );
                println!("{}", f(|_| true));
            }
        "#
        .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(language.clone(), &buffer);

    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(2, 0)..Point::new(2, 0),
        &[
            "...(function_item ... (block (expression_statement (macro_invocation...",
            "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
        ],
    );
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(2, 14)..Point::new(2, 16),
        &[
            "...(function_item ...",
            "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
            "...(array_expression (struct_expression ...",
        ],
    );
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(3, 14)..Point::new(3, 16),
        &[
            "...(function_item ...",
            "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
            "...(array_expression (field_expression ...",
        ],
    );
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(5, 12)..Point::new(5, 16),
        &[
            "...(function_item ...",
            "...(call_expression ... (arguments (closure_expression ...",
        ],
    );

    // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
    let macro_name_range = range_for_text(&buffer, "vec!");
    buffer.edit([(macro_name_range, "&")]);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(language.clone(), &buffer);

    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(2, 14)..Point::new(2, 16),
        &[
            "...(function_item ...",
            "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
        ],
    );

    // Put the vec! macro back, adding back the syntactic layer.
    buffer.undo();
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(language, &buffer);

    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(2, 14)..Point::new(2, 16),
        &[
            "...(function_item ...",
            "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
            "...(array_expression (struct_expression ...",
        ],
    );
}

#[gpui::test]
fn test_syntax_map_languages_match_layers_for_range(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let markdown = markdown_lang();
    let markdown_inline = Arc::new(markdown_inline_lang());
    registry.add(markdown.clone());
    registry.add(markdown_inline);
    registry.add(rust_lang());

    let buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r#"
            This is `inline`.

            ```rs
            fn a() {}
            ```
        "#
        .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(markdown, &buffer);

    let all_language_names = syntax_map
        .languages(&buffer, true)
        .map(|language| language.name().to_string())
        .collect::<Vec<_>>();
    let all_layer_language_names = syntax_map
        .layers_for_range(0..buffer.len(), &buffer, true)
        .map(|layer| layer.language.name().to_string())
        .collect::<Vec<_>>();

    assert_eq!(all_language_names, all_layer_language_names);
    assert!(
        all_language_names
            .iter()
            .any(|language_name| language_name == "Markdown-Inline"),
        "expected hidden languages to be included when include_hidden is true"
    );
    assert!(
        all_language_names
            .iter()
            .any(|language_name| language_name == "Markdown")
    );
    assert!(
        all_language_names
            .iter()
            .any(|language_name| language_name == "Rust")
    );

    let visible_language_names = syntax_map
        .languages(&buffer, false)
        .map(|language| language.name().to_string())
        .collect::<Vec<_>>();
    let visible_layer_language_names = syntax_map
        .layers_for_range(0..buffer.len(), &buffer, false)
        .map(|layer| layer.language.name().to_string())
        .collect::<Vec<_>>();

    assert_eq!(visible_language_names, visible_layer_language_names);
    assert!(
        !visible_language_names
            .iter()
            .any(|language_name| language_name == "Markdown-Inline"),
        "expected hidden languages to be excluded when include_hidden is false"
    );
    assert!(
        visible_language_names
            .iter()
            .any(|language_name| language_name == "Markdown")
    );
    assert!(
        visible_language_names
            .iter()
            .any(|language_name| language_name == "Rust")
    );
}

#[gpui::test]
fn test_dynamic_language_injection(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let markdown = markdown_lang();
    let markdown_inline = Arc::new(markdown_inline_lang());
    registry.add(markdown.clone());
    registry.add(markdown_inline.clone());
    registry.add(rust_lang());
    registry.add(Arc::new(ruby_lang()));

    let mut buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r#"
            This is a code block:

            ```rs
            fn foo() {}
            ```
        "#
        .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry.clone());
    syntax_map.reparse(markdown.clone(), &buffer);
    syntax_map.reparse(markdown_inline.clone(), &buffer);
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(3, 0)..Point::new(3, 0),
        &[
            "(document (section (paragraph (inline)) (fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (block_continuation) (code_fence_content (block_continuation)) (fenced_code_block_delimiter))))",
            "(inline (code_span (code_span_delimiter) (code_span_delimiter)))",
            "...(function_item name: (identifier) parameters: (parameters) body: (block)...",
        ],
    );

    // Replace `rs` with a path to ending in `.rb` in code block.
    let macro_name_range = range_for_text(&buffer, "rs");
    buffer.edit([(macro_name_range, "foo/bar/baz.rb")]);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(markdown.clone(), &buffer);
    syntax_map.reparse(markdown_inline.clone(), &buffer);
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(3, 0)..Point::new(3, 0),
        &[
            "(document (section (paragraph (inline)) (fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (block_continuation) (code_fence_content (block_continuation)) (fenced_code_block_delimiter))))",
            "(inline (code_span (code_span_delimiter) (code_span_delimiter)))",
            "...(call method: (identifier) arguments: (argument_list (call method: (identifier) arguments: (argument_list) block: (block)...",
        ],
    );

    // Replace Ruby with a language that hasn't been loaded yet.
    let macro_name_range = range_for_text(&buffer, "foo/bar/baz.rb");
    buffer.edit([(macro_name_range, "html")]);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(markdown.clone(), &buffer);
    syntax_map.reparse(markdown_inline.clone(), &buffer);
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(3, 0)..Point::new(3, 0),
        &[
            "(document (section (paragraph (inline)) (fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (block_continuation) (code_fence_content (block_continuation)) (fenced_code_block_delimiter))))",
            "(inline (code_span (code_span_delimiter) (code_span_delimiter)))",
        ],
    );
    assert!(syntax_map.contains_unknown_injections());

    registry.add(Arc::new(html_lang()));
    syntax_map.reparse(markdown, &buffer);
    syntax_map.reparse(markdown_inline, &buffer);
    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(3, 0)..Point::new(3, 0),
        &[
            "(document (section (paragraph (inline)) (fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (block_continuation) (code_fence_content (block_continuation)) (fenced_code_block_delimiter))))",
            "(inline (code_span (code_span_delimiter) (code_span_delimiter)))",
            "(document (text))",
        ],
    );
    assert!(!syntax_map.contains_unknown_injections());
}

#[gpui::test]
fn test_rust_json_macro_empty_string_highlighting(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = rust_lang();
    registry.add(language.clone());

    let buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r#"
            serde_json::json!({
                "email": "",
                "password": "password123",
                "requires2FA": false
            })
        "#
        .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(language, &buffer);

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["string"],
        r#"
            serde_json::json!({
                «"email"»: «""»,
                «"password"»: «"password123"»,
                «"requires2FA"»: false
            })
        "#,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["boolean"],
        r#"
            serde_json::json!({
                "email": "",
                "password": "password123",
                "requires2FA": «false»
            })
        "#,
    );
}

#[gpui::test]
fn test_rust_sql_macro_injection_without_registered_sql(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = rust_lang();
    registry.add(language.clone());

    for source in [
        r#"fn main() { sql!("SELECT * FROM carts"); }"#,
        r##"fn main() { sql!(r#"SELECT * FROM carts WHERE status = 'open'"#); }"##,
        r####"fn main() { sql!(r###"SELECT * FROM carts WHERE note LIKE '%"##%'"###); }"####,
        "fn main() { sql!(SELECT * FROM carts); }",
    ] {
        let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), source);
        let mut syntax_map = SyntaxMap::new(&buffer);
        syntax_map.set_language_registry(registry.clone());
        syntax_map.reparse(language.clone(), &buffer);

        assert!(
            syntax_map.contains_unknown_injections(),
            "expected sql! to trigger an unknown SQL injection in {source:?}"
        );
    }

    for source in [
        r#"fn main() { not_sql!("SELECT * FROM carts"); }"#,
        r##"fn main() { other_macro!(r#"SELECT * FROM carts"#); }"##,
        r#"fn main() { plain_function("SELECT * FROM carts"); }"#,
    ] {
        let buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), source);
        let mut syntax_map = SyntaxMap::new(&buffer);
        syntax_map.set_language_registry(registry.clone());
        syntax_map.reparse(language.clone(), &buffer);

        assert!(
            !syntax_map.contains_unknown_injections(),
            "expected non-sql! code not to trigger an unknown SQL injection in {source:?}"
        );
    }
}

#[gpui::test]
fn test_rust_sql_macro_injection_ranges(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = rust_lang();
    registry.add(language.clone());
    registry.add(Arc::new(sql_lang()));

    let buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r####"
            fn main() {
                sql!("SELECT normal FROM carts");
                sql!("SELECT trailing FROM carts",);
                sql!(r#"SELECT raw FROM carts"#);
                sql!(r###"SELECT raw_hashes FROM carts WHERE note LIKE '%"##%'"###);
                sql!(
                    r#"
                    SELECT multiline
                    FROM carts
                    "#
                );
                sql!(SELECT unquoted FROM carts);
                not_sql!(r#"SELECT not_sql FROM carts"#);
            }
        "####
            .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(language, &buffer);

    for text in [
        "normal",
        "trailing",
        "raw",
        "raw_hashes",
        "multiline",
        "unquoted",
    ] {
        assert_language_range_count_at_text(&syntax_map, &buffer, "SQL", text, 1);
    }

    for text in [
        r#""SELECT normal"#,
        r#""SELECT trailing"#,
        r##"r#"SELECT raw"##,
        r####"r###"SELECT raw_hashes"####,
        r#"not_sql"#,
    ] {
        assert_language_range_count_at_text(&syntax_map, &buffer, "SQL", text, 0);
    }

    for (text, offset) in [
        (r#"carts");"#, "carts".len()),
        (r#"carts",);"#, "carts".len()),
        (r##"carts"#);"##, "carts".len()),
        (r####"%'"###);"####, "%'".len()),
    ] {
        assert_language_range_count_at_text_offset(&syntax_map, &buffer, "SQL", text, offset, 0);
    }
}

#[gpui::test]
fn test_typing_multiple_new_injections(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "Rust",
        &[
            "fn a() { test_macro }",
            "fn a() { test_macro«!» }",
            "fn a() { test_macro!«()» }",
            "fn a() { test_macro!(«b») }",
            "fn a() { test_macro!(b«.») }",
            "fn a() { test_macro!(b.«c») }",
            "fn a() { test_macro!(b.c«()») }",
            "fn a() { test_macro!(b.c(«vec»)) }",
            "fn a() { test_macro!(b.c(vec«!»)) }",
            "fn a() { test_macro!(b.c(vec!«[]»)) }",
            "fn a() { test_macro!(b.c(vec![«d»])) }",
            "fn a() { test_macro!(b.c(vec![d«.»])) }",
            "fn a() { test_macro!(b.c(vec![d.«e»])) }",
        ],
        cx,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["property"],
        "fn a() { test_macro!(b.«c»(vec![d.«e»])) }",
    );
}

#[gpui::test]
fn test_pasting_new_injection_line_between_others(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "Rust",
        &[
            "
                fn a() {
                    b!(B {});
                    c!(C {});
                    d!(D {});
                    e!(E {});
                    f!(F {});
                    g!(G {});
                }
            ",
            "
                fn a() {
                    b!(B {});
                    c!(C {});
                    d!(D {});
                «    h!(H {});
                »    e!(E {});
                    f!(F {});
                    g!(G {});
                }
            ",
        ],
        cx,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["type"],
        "
        fn a() {
            b!(«B» {});
            c!(«C» {});
            d!(«D» {});
            h!(«H» {});
            e!(«E» {});
            f!(«F» {});
            g!(«G» {});
        }
        ",
    );
}

#[gpui::test]
fn test_joining_injections_with_child_injections(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "Rust",
        &[
            "
                fn a() {
                    b!(
                        c![one.two.three],
                        d![four.five.six],
                    );
                    e!(
                        f![seven.eight],
                    );
                }
            ",
            "
                fn a() {
                    b!(
                        c![one.two.three],
                        d![four.five.six],
                    ˇ    f![seven.eight],
                    );
                }
            ",
        ],
        cx,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["property"],
        "
        fn a() {
            b!(
                c![one.«two».«three»],
                d![four.«five».«six»],
                f![seven.«eight»],
            );
        }
        ",
    );
}

#[gpui::test]
fn test_editing_edges_of_injection(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            "
                fn a() {
                    b!(c!())
                }
            ",
            "
                fn a() {
                    «d»!(c!())
                }
            ",
            "
                fn a() {
                    «e»d!(c!())
                }
            ",
            "
                fn a() {
                    ed!«[»c!()«]»
                }
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_edits_preceding_and_intersecting_injection(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            //
            "const aaaaaaaaaaaa: B = c!(d(e.f));",
            "const aˇa: B = c!(d(eˇ));",
        ],
        cx,
    );
}

#[gpui::test]
fn test_non_local_changes_create_injections(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            "
                // a! {
                    static B: C = d;
                // }
            ",
            "
                ˇa! {
                    static B: C = d;
                ˇ}
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_creating_many_injections_in_one_edit(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            "
                fn a() {
                    one(Two::three(3));
                    four(Five::six(6));
                    seven(Eight::nine(9));
                }
            ",
            "
                fn a() {
                    one«!»(Two::three(3));
                    four«!»(Five::six(6));
                    seven«!»(Eight::nine(9));
                }
            ",
            "
                fn a() {
                    one!(Two::three«!»(3));
                    four!(Five::six«!»(6));
                    seven!(Eight::nine«!»(9));
                }
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_editing_across_injection_boundary(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            "
                fn one() {
                    two();
                    three!(
                        three.four,
                        five.six,
                    );
                }
            ",
            "
                fn one() {
                    two();
                    th«irty_five![»
                        three.four,
                        five.six,
                    «   seven.eight,
                    ];»
                }
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_removing_injection_by_replacing_across_boundary(cx: &mut App) {
    test_edit_sequence(
        "Rust",
        &[
            "
                fn one() {
                    two!(
                        three.four,
                    );
                }
            ",
            "
                fn one() {
                    t«en
                        .eleven(
                        twelve,
                    »
                        three.four,
                    );
                }
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_combined_injections_simple(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "ERB",
        &[
            "
                <body>
                    <% if @one %>
                        <div class=one>
                    <% else %>
                        <div class=two>
                    <% end %>
                    </div>
                </body>
            ",
            "
                <body>
                    <% if @one %>
                        <div class=one>
                    ˇ else ˇ
                        <div class=two>
                    <% end %>
                    </div>
                </body>
            ",
            "
                <body>
                    <% if @one «;» end %>
                    </div>
                </body>
            ",
        ],
        cx,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["tag", "ivar"],
        "
            <«body»>
                <% if «@one» ; end %>
                </«div»>
            </«body»>
        ",
    );
}

#[gpui::test]
fn test_combined_injections_empty_ranges(cx: &mut App) {
    test_edit_sequence(
        "ERB",
        &[
            "
                <% if @one %>
                <% else %>
                <% end %>
            ",
            "
                <% if @one %>
                ˇ<% end %>
            ",
        ],
        cx,
    );
}

#[gpui::test]
fn test_combined_injections_edit_edges_of_ranges(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "ERB",
        &[
            "
                <%= one @two %>
                <%= three @four %>
            ",
            "
                <%= one @two %ˇ
                <%= three @four %>
            ",
            "
                <%= one @two %«>»
                <%= three @four %>
            ",
        ],
        cx,
    );

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["tag", "ivar"],
        "
            <%= one «@two» %>
            <%= three «@four» %>
        ",
    );
}

#[gpui::test]
fn test_combined_injections_splitting_some_injections(cx: &mut App) {
    let (_buffer, _syntax_map) = test_edit_sequence(
        "ERB",
        &[
            r#"
                <%A if b(:c) %>
                d
                <% end %>
                eee
                <% f %>
            "#,
            r#"
                <%« AAAAAAA %>
                hhhhhhh
                <%=» if b(:c) %>
                d
                <% end %>
                eee
                <% f %>
            "#,
        ],
        cx,
    );
}

#[gpui::test]
fn test_combined_injections_editing_after_last_injection(cx: &mut App) {
    test_edit_sequence(
        "ERB",
        &[
            r#"
                <% foo %>
                <div></div>
                <% bar %>
            "#,
            r#"
                <% foo %>
                <div></div>
                <% bar %>«
                more text»
            "#,
        ],
        cx,
    );
}

#[gpui::test]
fn test_combined_injections_inside_injections(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "Markdown",
        &[
            r#"
                here is
                some
                ERB code:

                ```erb
                <ul>
                <% people.each do |person| %>
                    <li><%= person.name %></li>
                    <li><%= person.age %></li>
                <% end %>
                </ul>
                ```
            "#,
            r#"
                here is
                some
                ERB code:

                ```erb
                <ul>
                <% people«2».each do |person| %>
                    <li><%= person.name %></li>
                    <li><%= person.age %></li>
                <% end %>
                </ul>
                ```
            "#,
            // Inserting a comment character inside one code directive
            // does not cause the other code directive to become a comment,
            // because newlines are included in between each injection range.
            r#"
                here is
                some
                ERB code:

                ```erb
                <ul>
                <% people2.each do |person| %>
                    <li><%= «# »person.name %></li>
                    <li><%= person.age %></li>
                <% end %>
                </ul>
                ```
            "#,
        ],
        cx,
    );

    // Check that the code directive below the ruby comment is
    // not parsed as a comment.
    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["method"],
        "
            here is
            some
            ERB code:

            ```erb
            <ul>
            <% people2.«each» do |person| %>
                <li><%= # person.name %></li>
                <li><%= person.«age» %></li>
            <% end %>
            </ul>
            ```
        ",
    );
}

#[gpui::test]
fn test_empty_combined_injections_inside_injections(cx: &mut App) {
    let (buffer, syntax_map) = test_edit_sequence(
        "Markdown",
        &[r#"
            ```erb
            hello
            ```

            goodbye
        "#],
        cx,
    );

    assert_layers_for_range(
        &syntax_map,
        &buffer,
        Point::new(0, 0)..Point::new(5, 0),
        &[
            // Markdown document
            "(document (section (fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (block_continuation) (code_fence_content (block_continuation)) (fenced_code_block_delimiter)) (paragraph (inline))))",
            // ERB template in the code block
            "(template...",
            // Markdown inline content
            "(inline)",
            // The ruby syntax tree should be empty, since there are
            // no interpolations in the ERB template.
            "(program)",
            // HTML within the ERB
            "(document (text))",
        ],
    );
}

#[gpui::test]
fn test_combined_injection_with_leading_content_layer_ordering(cx: &mut App) {
    // Regression test for "layers out of order".
    //
    // A combined injection stores its layer `range` as the parent's full
    // `outer_range`, but the parse queue orders steps by `ParseStep::range()`,
    // which for a combined injection is the parsed node span. When the parent
    // layer has content before its first injected range (here: leading HEEx
    // markup before the first `<% %>` directive), those two ranges start at
    // different offsets. A nested combined injection then inherits the wide
    // `outer_range` (starting at 0) but is ordered by the narrow node span,
    // landing after a sibling injection and breaking the sorted-by-start
    // invariant.
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let heex = Arc::new(heex_lang());
    let elixir = Arc::new(
        Language::new(
            LanguageConfig {
                name: LanguageName::new_static("Elixir"),
                matcher: Arc::new(LanguageMatcher {
                    path_suffixes: vec!["ex".into()],
                    ..Default::default()
                }),
                ..LanguageConfig::default()
            },
            Some(tree_sitter::Language::new(tree_sitter_elixir::LANGUAGE)),
        )
        .with_injection_query(
            r#"
            ((string (quoted_content) @injection.content)
             (#set! injection.language "html")
             (#set! injection.combined))
            ((string (quoted_content) @injection.content)
             (#set! injection.language "Markdown")
             (#set! injection.combined))
            "#,
        )
        .unwrap(),
    );
    registry.add(heex.clone());
    registry.add(elixir);
    registry.add(Arc::new(html_lang()));
    registry.add(markdown_lang());

    let buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        r#"
<div>leading markup before any directive</div>
<a href={"early-attr"}>x</a>
<%= "mid" %>
<% y = "code" %>
<b class={"late-attr"}>z</b>
<%= "tail" %>
"#
        .unindent(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    // In debug builds, `reparse` runs `check_invariants`, which panics with
    // "layers out of order" if the produced layers are not correctly sorted.
    syntax_map.reparse(heex, &buffer);
}

#[gpui::test]
fn test_markdown_injections_with_same_start_and_different_ends(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let markdown = markdown_lang();
    let markdown_inline = Arc::new(
        markdown_inline_lang()
            .with_injection_query(include_str!(
                "../../../grammars/src/markdown-inline/injections.scm"
            ))
            .unwrap(),
    );
    let html = Arc::new(html_lang());
    registry.add(markdown.clone());
    registry.add(markdown_inline.clone());
    registry.add(html.clone());

    let mut buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        "a\n\n$x$ <b>\n".to_string(),
    );
    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(markdown.clone(), &buffer);
    assert!(syntax_map.contains_unknown_injections());

    for (range, replacement, document_end, inline_end, latex_end) in
        [(4..5, "中", 13, 12, 8), (4..7, "x", 11, 10, 6)]
    {
        buffer.edit([(range, replacement)]);
        syntax_map.interpolate(&buffer);
        syntax_map.reparse(markdown.clone(), &buffer);

        assert_eq!(
            syntax_map
                .snapshot
                .layers
                .iter()
                .map(|layer| (
                    layer.depth,
                    layer.range.to_offset(&buffer),
                    layer.content.language_id(),
                ))
                .collect::<Vec<_>>(),
            vec![
                (0, 0..document_end, Some(markdown.id)),
                (1, 0..1, Some(markdown_inline.id)),
                (1, 3..inline_end, Some(markdown_inline.id)),
                (2, 0..1, Some(html.id)),
                (2, 3..inline_end, Some(html.id)),
                (2, 3..latex_end, None),
            ],
        );
        assert!(syntax_map.contains_unknown_injections());
    }
}

#[gpui::test]
fn test_comment_triggered_injection_toggle(cx: &mut App) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

    let python = Arc::new(python_lang());
    let comment = Arc::new(comment_lang());
    registry.add(python.clone());
    registry.add(comment);
    // Note: SQL is an extension language (not built-in as of v0.222.0), so we can use
    // contains_unknown_injections() to detect when the injection is triggered.
    // We register a mock "comment" language because Python injects all comments as
    // language "comment", and we only want SQL to trigger unknown injections.

    // Start with Python code with incomplete #sq comment (not enough to trigger injection)
    let mut buffer = Buffer::new(
        ReplicaId::LOCAL,
        BufferId::new(1).unwrap(),
        "#sq\ncmd = \"SELECT col1, col2 FROM tbl\"".to_string(),
    );

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry);
    syntax_map.reparse(python.clone(), &buffer);

    // Should have no unknown injections (#sq doesn't match the injection pattern)
    assert!(
        !syntax_map.contains_unknown_injections(),
        "Expected no unknown injections with incomplete #sq comment"
    );

    // Complete the comment by adding 'l' to make #sql
    let sq_end = buffer.as_rope().to_string().find('\n').unwrap();
    buffer.edit([(sq_end..sq_end, "l")]);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(python.clone(), &buffer);

    // Should now have unknown injections (SQL injection triggered but SQL not registered)
    assert!(
        syntax_map.contains_unknown_injections(),
        "Expected unknown injections after completing #sql comment"
    );

    // Remove the 'l' to go back to #sq
    let l_position = buffer.as_rope().to_string().find("l\n").unwrap();
    buffer.edit([(l_position..l_position + 1, "")]);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(python, &buffer);

    // Should have no unknown injections again - SQL injection should be invalidated
    assert!(
        !syntax_map.contains_unknown_injections(),
        "Expected no unknown injections after removing 'l' from #sql comment"
    );
}

#[gpui::test]
fn test_injection_grouped_by_host(cx: &mut App) {
    // Each SQL layer is described by the buffer text of the fragments it is parsed from,
    // so that interpolated strings are asserted to produce a single layer covering every
    // fragment of the string.
    let cases: &[(&str, &[&[&str]])] = &[
        (
            indoc! {r#"
                # sql
                cmd = "SELECT col1, col2 FROM tbl"
            "#},
            &[&["SELECT col1, col2 FROM tbl"]],
        ),
        (
            indoc! {r#"
                # sql
                cmd = f"SELECT col1 FROM tbl WHERE col2 = '{my_var}'"
            "#},
            &[&["SELECT col1 FROM tbl WHERE col2 = '", "'"]],
        ),
        (
            indoc! {r#"
                # sql
                cmd = f"SELECT {col1}, {col2} FROM {tbl}"
            "#},
            &[&["SELECT ", ", ", " FROM "]],
        ),
        (
            indoc! {r#"
                cursor.execute(
                    # sql
                    f"SELECT col1 FROM tbl WHERE col2 = '{my_var}'"
                )
            "#},
            &[&["SELECT col1 FROM tbl WHERE col2 = '", "'"]],
        ),
        (
            indoc! {r#"
                cursor.execute(
                    # sql
                    f"SELECT col1 FROM tbl WHERE col2 = '{my_var}'"
                )

                cursor.execute(
                    # sql
                    f"INSERT INTO tbl VALUES ('{val1}')"
                )
            "#},
            &[
                &["SELECT col1 FROM tbl WHERE col2 = '", "'"],
                &["INSERT INTO tbl VALUES ('", "')"],
            ],
        ),
    ];

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let python = Arc::new(python_lang());
    registry.add(python.clone());
    registry.add(Arc::new(comment_lang()));
    registry.add(Arc::new(sql_lang()));

    for (buffer_index, (text, expected_layers)) in cases.iter().enumerate() {
        let buffer = Buffer::new(
            ReplicaId::LOCAL,
            BufferId::new(buffer_index as u64 + 1).unwrap(),
            text.to_string(),
        );
        let mut syntax_map = SyntaxMap::new(&buffer);
        syntax_map.set_language_registry(registry.clone());
        syntax_map.reparse(python.clone(), &buffer);

        let sql_layers = syntax_map
            .layers_for_range(0..buffer.len(), &buffer, true)
            .filter(|layer| layer.language.name() == "SQL")
            .map(|layer| match layer.included_sub_ranges {
                Some(sub_ranges) => sub_ranges
                    .iter()
                    .map(|range| buffer.text_for_range(range.clone()).collect::<String>())
                    .collect::<Vec<_>>(),
                None => {
                    vec![
                        buffer
                            .text_for_range(layer.node().byte_range())
                            .collect::<String>(),
                    ]
                }
            })
            .collect::<Vec<_>>();

        assert_eq!(sql_layers, *expected_layers, "buffer text:\n{text}");
    }
}

#[gpui::test]
fn test_syntax_map_languages_loading_with_erb(cx: &mut App) {
    let text = r#"
        <body>
            <% if @one %>
                <div class=one>
            <% else %>
                <div class=two>
            <% end %>
            </div>
        </body>
    "#
    .unindent();

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), text);

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry.clone());

    let language = Arc::new(erb_lang());

    log::info!("parsing");
    registry.add(language.clone());
    syntax_map.reparse(language.clone(), &buffer);

    log::info!("loading html");
    registry.add(Arc::new(html_lang()));
    syntax_map.reparse(language.clone(), &buffer);

    log::info!("loading ruby");
    registry.add(Arc::new(ruby_lang()));
    syntax_map.reparse(language.clone(), &buffer);

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["tag", "ivar"],
        "
            <«body»>
                <% if «@one» %>
                    <«div» class=one>
                <% else %>
                    <«div» class=two>
                <% end %>
                </«div»>
            </«body»>
        ",
    );

    let text = r#"
        <body>
            <% if @one«_hundred» %>
                <div class=one>
            <% else %>
                <div class=two>
            <% end %>
            </div>
        </body>
    "#
    .unindent();

    log::info!("editing");
    buffer.edit_via_marked_text(&text);
    syntax_map.interpolate(&buffer);
    syntax_map.reparse(language, &buffer);

    assert_capture_ranges(
        &syntax_map,
        &buffer,
        &["tag", "ivar"],
        "
            <«body»>
                <% if «@one_hundred» %>
                    <«div» class=one>
                <% else %>
                    <«div» class=two>
                <% end %>
                </«div»>
            </«body»>
        ",
    );
}

#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_rust_macros(rng: StdRng, cx: &mut App) {
    let text = r#"
        fn test_something() {
            let vec = vec![5, 1, 3, 8];
            assert_eq!(
                vec
                    .into_iter()
                    .map(|i| i * 2)
                    .collect::<Vec<usize>>(),
                vec![
                    5 * 2, 1 * 2, 3 * 2, 8 * 2
                ],
            );
        }
    "#
    .unindent()
    .repeat(2);

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = rust_lang();
    registry.add(language.clone());

    test_random_edits(text, registry, language, rng);
}

#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_with_erb(rng: StdRng, cx: &mut App) {
    let text = r#"
        <div id="main">
        <% if one?(:two) %>
            <p class="three" four>
            <%= yield :five %>
            </p>
        <% elsif Six.seven(8) %>
            <p id="three" four>
            <%= yield :five %>
            </p>
        <% else %>
            <span>Ok</span>
        <% end %>
        </div>
    "#
    .unindent()
    .repeat(5);

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = Arc::new(erb_lang());
    registry.add(language.clone());
    registry.add(Arc::new(ruby_lang()));
    registry.add(Arc::new(html_lang()));

    test_random_edits(text, registry, language, rng);
}

#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_with_python_sql(rng: StdRng, cx: &mut App) {
    let text = r#"
        # sql
        query = f"SELECT {col} FROM tbl WHERE name = '{name}' AND id = {id}"

        cursor.execute(
            # sql
            f"""
                INSERT INTO tbl (col1, col2)
                VALUES ('{one}', '{two}')
            """
        )
    "#
    .unindent()
    .repeat(5);

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = Arc::new(python_lang());
    registry.add(language.clone());
    registry.add(Arc::new(comment_lang()));
    registry.add(Arc::new(sql_lang()));

    test_random_edits(text, registry, language, rng);
}

#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_with_heex(rng: StdRng, cx: &mut App) {
    let text = r#"
        defmodule TheModule do
            def the_method(assigns) do
                ~H"""
                <%= if @empty do %>
                    <div class="h-4"></div>
                <% else %>
                    <div class="max-w-2xl w-full animate-pulse">
                    <div class="flex-1 space-y-4">
                        <div class={[@bg_class, "h-4 rounded-lg w-3/4"]}></div>
                        <div class={[@bg_class, "h-4 rounded-lg"]}></div>
                        <div class={[@bg_class, "h-4 rounded-lg w-5/6"]}></div>
                    </div>
                    </div>
                <% end %>
                """
            end
        end
    "#
    .unindent()
    .repeat(3);

    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let language = Arc::new(elixir_lang());
    registry.add(language.clone());
    registry.add(Arc::new(heex_lang()));
    registry.add(Arc::new(html_lang()));

    test_random_edits(text, registry, language, rng);
}

#[test]
fn test_flatten_capture_regions_with_nested_captures() {
    let outer = capture_ref(1);
    let inner = capture_ref(2);
    assert_eq!(
        flattened(0..12, &[(0..10, outer), (2..5, inner)]),
        vec![
            (0..2, vec![outer]),
            (2..5, vec![outer, inner]),
            (5..10, vec![outer]),
        ],
    );
}

#[test]
fn test_flatten_capture_regions_with_overlapping_captures() {
    let first = capture_ref(1);
    let second = capture_ref(2);
    assert_eq!(
        flattened(0..25, &[(0..10, first), (2..20, second)]),
        vec![
            (0..2, vec![first]),
            (2..10, vec![first, second]),
            (10..20, vec![second]),
        ],
        "a capture must not extend past its own end when overlapping another capture"
    );
}

#[test]
fn test_flatten_capture_regions_clips_to_the_requested_range() {
    let capture = capture_ref(1);
    assert_eq!(
        flattened(5..8, &[(0..10, capture)]),
        vec![(5..8, vec![capture])],
    );
    assert_eq!(
        flattened(0..6, &[(4..10, capture)]),
        vec![(4..6, vec![capture])],
    );
}

fn test_random_edits(
    text: String,
    registry: Arc<LanguageRegistry>,
    language: Arc<Language>,
    mut rng: StdRng,
) {
    let operations = env::var("OPERATIONS")
        .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
        .unwrap_or(10);

    let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), text);

    let mut syntax_map = SyntaxMap::new(&buffer);
    syntax_map.set_language_registry(registry.clone());
    syntax_map.reparse(language.clone(), &buffer);

    let mut reference_syntax_map = SyntaxMap::new(&buffer);
    reference_syntax_map.set_language_registry(registry);

    log::info!("initial text:\n{}", buffer.text());

    for _ in 0..operations {
        let prev_buffer = buffer.snapshot().clone();
        let prev_syntax_map = syntax_map.snapshot();

        buffer.randomly_edit(&mut rng, 3);
        log::info!("text:\n{}", buffer.text());

        syntax_map.interpolate(&buffer);
        check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);

        syntax_map.reparse(language.clone(), &buffer);

        reference_syntax_map.clear(&buffer);
        reference_syntax_map.reparse(language.clone(), &buffer);
    }

    for i in 0..operations {
        let i = operations - i - 1;
        buffer.undo();
        log::info!("undoing operation {}", i);
        log::info!("text:\n{}", buffer.text());

        syntax_map.interpolate(&buffer);
        syntax_map.reparse(language.clone(), &buffer);

        reference_syntax_map.clear(&buffer);
        reference_syntax_map.reparse(language.clone(), &buffer);
        assert_eq!(
            syntax_map.layers(&buffer).len(),
            reference_syntax_map.layers(&buffer).len(),
            "wrong number of layers after undoing edit {i}"
        );
    }

    let layers = syntax_map.layers(&buffer);
    let reference_layers = reference_syntax_map.layers(&buffer);
    for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers) {
        assert_eq!(
            edited_layer.node().to_sexp(),
            reference_layer.node().to_sexp()
        );
        assert_eq!(edited_layer.node().range(), reference_layer.node().range());
    }
}

fn check_interpolation(
    old_syntax_map: &SyntaxSnapshot,
    new_syntax_map: &SyntaxSnapshot,
    old_buffer: &BufferSnapshot,
    new_buffer: &BufferSnapshot,
) {
    let edits = new_buffer
        .edits_since::<usize>(old_buffer.version())
        .collect::<Vec<_>>();

    for (old_layer, new_layer) in old_syntax_map
        .layers
        .iter()
        .zip(new_syntax_map.layers.iter())
    {
        assert_eq!(old_layer.range, new_layer.range);
        let Some(old_tree) = old_layer.content.tree() else {
            continue;
        };
        let Some(new_tree) = new_layer.content.tree() else {
            continue;
        };
        let old_start_byte = old_layer.range.start.to_offset(old_buffer);
        let new_start_byte = new_layer.range.start.to_offset(new_buffer);
        let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
        let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
        let old_node = old_tree.root_node_with_offset(old_start_byte, old_start_point);
        let new_node = new_tree.root_node_with_offset(new_start_byte, new_start_point);
        check_node_edits(
            old_layer.depth,
            &old_layer.range,
            old_node,
            new_node,
            old_buffer,
            new_buffer,
            &edits,
        );
    }

    fn check_node_edits(
        depth: usize,
        range: &Range<Anchor>,
        old_node: Node,
        new_node: Node,
        old_buffer: &BufferSnapshot,
        new_buffer: &BufferSnapshot,
        edits: &[text::Edit<usize>],
    ) {
        assert_eq!(old_node.kind(), new_node.kind());

        let old_range = old_node.byte_range();
        let new_range = new_node.byte_range();

        let is_edited = edits
            .iter()
            .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
        if is_edited {
            assert!(
                new_node.has_changes(),
                concat!(
                    "failed to mark node as edited.\n",
                    "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
                    "node kind: {}, old node range: {:?}, new node range: {:?}",
                ),
                depth,
                range.to_offset(old_buffer),
                range.to_offset(new_buffer),
                new_node.kind(),
                old_range,
                new_range,
            );
        }

        if !new_node.has_changes() {
            assert_eq!(
                old_buffer
                    .text_for_range(old_range.clone())
                    .collect::<String>(),
                new_buffer
                    .text_for_range(new_range.clone())
                    .collect::<String>(),
                concat!(
                    "mismatched text for node\n",
                    "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
                    "node kind: {}, old node range:{:?}, new node range:{:?}",
                ),
                depth,
                range.to_offset(old_buffer),
                range.to_offset(new_buffer),
                new_node.kind(),
                old_range,
                new_range,
            );
        }

        for i in 0..new_node.child_count() {
            check_node_edits(
                depth,
                range,
                old_node.child(i).unwrap(),
                new_node.child(i).unwrap(),
                old_buffer,
                new_buffer,
                edits,
            )
        }
    }
}

fn test_edit_sequence(language_name: &str, steps: &[&str], cx: &mut App) -> (Buffer, SyntaxMap) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    registry.add(Arc::new(elixir_lang()));
    registry.add(Arc::new(heex_lang()));
    registry.add(rust_lang());
    registry.add(Arc::new(ruby_lang()));
    registry.add(Arc::new(html_lang()));
    registry.add(Arc::new(erb_lang()));
    registry.add(markdown_lang());
    registry.add(Arc::new(markdown_inline_lang()));

    let language = registry
        .language_for_name(language_name)
        .now_or_never()
        .unwrap()
        .unwrap();
    let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), "");

    let mut mutated_syntax_map = SyntaxMap::new(&buffer);
    mutated_syntax_map.set_language_registry(registry.clone());
    mutated_syntax_map.reparse(language.clone(), &buffer);

    for (i, marked_string) in steps.iter().enumerate() {
        let marked_string = marked_string.unindent();
        log::info!("incremental parse {i}: {marked_string:?}");
        buffer.edit_via_marked_text(&marked_string);

        // Reparse the syntax map
        mutated_syntax_map.interpolate(&buffer);
        mutated_syntax_map.reparse(language.clone(), &buffer);

        // Create a second syntax map from scratch
        log::info!("fresh parse {i}: {marked_string:?}");
        let mut reference_syntax_map = SyntaxMap::new(&buffer);
        reference_syntax_map.set_language_registry(registry.clone());
        reference_syntax_map.reparse(language.clone(), &buffer);

        // Compare the mutated syntax map to the new syntax map
        let mutated_layers = mutated_syntax_map.layers(&buffer);
        let reference_layers = reference_syntax_map.layers(&buffer);
        assert_eq!(
            mutated_layers.len(),
            reference_layers.len(),
            "wrong number of layers at step {i}"
        );
        for (edited_layer, reference_layer) in mutated_layers.into_iter().zip(reference_layers) {
            assert_eq!(
                edited_layer.node().to_sexp(),
                reference_layer.node().to_sexp(),
                "different layer at step {i}"
            );
            assert_eq!(
                edited_layer.node().range(),
                reference_layer.node().range(),
                "different layer at step {i}"
            );
        }
    }

    (buffer, mutated_syntax_map)
}

fn html_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "HTML".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["html".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_html::LANGUAGE.into()),
    )
    .with_highlights_query(
        r#"
            (tag_name) @tag
            (erroneous_end_tag_name) @tag
            (attribute_name) @property
        "#,
    )
    .unwrap()
}

fn ruby_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "Ruby".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["rb".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_ruby::LANGUAGE.into()),
    )
    .with_highlights_query(
        r#"
            ["if" "do" "else" "end"] @keyword
            (instance_variable) @ivar
            (call method: (identifier) @method)
        "#,
    )
    .unwrap()
}

fn erb_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "ERB".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["erb".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_embedded_template::LANGUAGE.into()),
    )
    .with_highlights_query(
        r#"
            ["<%" "%>"] @keyword
        "#,
    )
    .unwrap()
    .with_injection_query(
        r#"
            (
                (code) @injection.content
                (#set! injection.language "ruby")
                (#set! injection.combined)
            )

            (
                (content) @injection.content
                (#set! injection.language "html")
                (#set! injection.combined)
            )
        "#,
    )
    .unwrap()
}

fn elixir_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "Elixir".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["ex".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_elixir::LANGUAGE.into()),
    )
    .with_highlights_query(
        r#"

        "#,
    )
    .unwrap()
}

fn heex_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "HEEx".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["heex".into()],
                ..Default::default()
            })
            .into(),
            ..Default::default()
        },
        Some(tree_sitter_heex::LANGUAGE.into()),
    )
    .with_injection_query(
        r#"
        (
          (directive
            [
              (partial_expression_value)
              (expression_value)
              (ending_expression_value)
            ] @injection.content)
          (#set! injection.language "elixir")
          (#set! injection.combined)
        )

        ((expression (expression_value) @injection.content)
         (#set! injection.language "elixir"))
        "#,
    )
    .unwrap()
}

fn python_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "Python".into(),
            matcher: (LanguageMatcher {
                path_suffixes: vec!["py".into()],
                ..Default::default()
            })
            .into(),
            line_comments: vec!["# ".into()],
            ..Default::default()
        },
        Some(tree_sitter_python::LANGUAGE.into()),
    )
    .with_queries(LanguageQueries {
        injections: Some(Cow::from(include_str!(
            "../../../grammars/src/python/injections.scm"
        ))),
        ..Default::default()
    })
    .expect("Could not parse Python queries")
}

fn comment_lang() -> Language {
    // Mock "comment" language to satisfy Python's comment injection.
    // Uses JSON grammar as a stand-in since we just need it to be registered.
    Language::new(
        LanguageConfig {
            name: "comment".into(),
            ..Default::default()
        },
        Some(tree_sitter_json::LANGUAGE.into()),
    )
}

/// Stands in for the real SQL language, which this crate does not depend on.
/// The grammar is irrelevant because these tests assert injected language ranges.
fn sql_lang() -> Language {
    Language::new(
        LanguageConfig {
            name: "SQL".into(),
            matcher: Arc::new(LanguageMatcher {
                path_suffixes: vec!["sql".into()],
                ..Default::default()
            }),
            ..Default::default()
        },
        Some(tree_sitter_json::LANGUAGE.into()),
    )
}

fn capture_ref(capture_id: u32) -> HighlightCaptureRef {
    HighlightCaptureRef {
        grammar_index: 0,
        capture_id: CaptureId(capture_id),
    }
}

fn flattened(
    range: Range<usize>,
    captures: &[(Range<usize>, HighlightCaptureRef)],
) -> Vec<(Range<usize>, Vec<HighlightCaptureRef>)> {
    flatten_capture_regions(range, captures.iter().cloned())
        .into_iter()
        .map(|region| (region.range, region.stack.to_vec()))
        .collect()
}

fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
    let start = buffer.as_rope().to_string().find(text).unwrap();
    start..start + text.len()
}

#[track_caller]
fn assert_language_range_count_at_text(
    syntax_map: &SyntaxMap,
    buffer: &Buffer,
    language_name: &str,
    text: &str,
    expected_count: usize,
) {
    assert_language_range_count_at_text_offset(
        syntax_map,
        buffer,
        language_name,
        text,
        0,
        expected_count,
    );
}

#[track_caller]
fn assert_language_range_count_at_text_offset(
    syntax_map: &SyntaxMap,
    buffer: &Buffer,
    language_name: &str,
    text: &str,
    offset_in_text: usize,
    expected_count: usize,
) {
    let offset = range_for_text(buffer, text).start;
    let offset = offset + offset_in_text;
    let actual_count = language_ranges(syntax_map, buffer, language_name)
        .into_iter()
        .filter(|range| range.start <= offset && offset < range.end)
        .count();

    assert_eq!(
        actual_count, expected_count,
        "wrong number of {language_name} ranges at {text:?}"
    );
}

fn language_ranges(
    syntax_map: &SyntaxMap,
    buffer: &Buffer,
    language_name: &str,
) -> Vec<Range<usize>> {
    syntax_map
        .layers_for_range(0..buffer.len(), buffer, true)
        .filter(|layer| layer.language.name().as_ref() == language_name)
        .flat_map(|layer| {
            let layer_offset = layer.offset.0;
            layer
                .tree
                .included_ranges()
                .into_iter()
                .map(move |range| layer_offset + range.start_byte..layer_offset + range.end_byte)
        })
        .collect()
}

#[track_caller]
fn assert_layers_for_range(
    syntax_map: &SyntaxMap,
    buffer: &BufferSnapshot,
    range: Range<Point>,
    expected_layers: &[&str],
) {
    let layers = syntax_map
        .layers_for_range(range, buffer, true)
        .collect::<Vec<_>>();
    assert_eq!(
        layers.len(),
        expected_layers.len(),
        "wrong number of layers"
    );
    for (i, (layer, expected_s_exp)) in layers.iter().zip(expected_layers.iter()).enumerate() {
        let actual_s_exp = layer.node().to_sexp();
        assert!(
            string_contains_sequence(
                &actual_s_exp,
                &expected_s_exp.split("...").collect::<Vec<_>>()
            ),
            "layer {i}:\n\nexpected: {expected_s_exp}\nactual:   {actual_s_exp}",
        );
    }
}

#[track_caller]
fn assert_capture_ranges(
    syntax_map: &SyntaxMap,
    buffer: &BufferSnapshot,
    highlight_query_capture_names: &[&str],
    marked_string: &str,
) {
    let mut actual_ranges = Vec::<Range<usize>>::new();
    let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
        grammar
            .highlights_config
            .as_ref()
            .map(|config| &config.query)
    });
    let queries = captures
        .grammars()
        .iter()
        .map(|grammar| &grammar.highlights_config.as_ref().unwrap().query)
        .collect::<Vec<_>>();
    for capture in captures {
        let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
        if highlight_query_capture_names.contains(name) {
            actual_ranges.push(capture.node.byte_range());
        }
    }
    actual_ranges.dedup();

    let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
    assert_eq!(text, buffer.text());
    assert_eq!(actual_ranges, expected_ranges);
}

pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
    let mut last_part_end = 0;
    for part in parts {
        if let Some(start_ix) = text[last_part_end..].find(part) {
            last_part_end = start_ix + part.len();
        } else {
            return false;
        }
    }
    true
}