diff --git a/crates/grammars/src/rust/injections.scm b/crates/grammars/src/rust/injections.scm index 4d6b67b9f81..f03d3b133a6 100644 --- a/crates/grammars/src/rust/injections.scm +++ b/crates/grammars/src/rust/injections.scm @@ -33,8 +33,25 @@ (scoped_identifier (identifier) @_macro_name .) ] + (token_tree + [ + (string_literal + (string_content) @injection.content) + (raw_string_literal + (string_content) @injection.content) + ]) + (#set! injection.language "sql") + (#any-of? @_macro_name "sql")) + +(macro_invocation + macro: [ + (identifier) @_macro_name + (scoped_identifier + (identifier) @_macro_name .) + ] + (token_tree) @injection.content (#any-of? @_macro_name "sql") - (_) @injection.content + (#not-match? @injection.content "^[({\\[]\\s*(\"|r#*\")") (#set! injection.language "sql")) ; lazy_regex diff --git a/crates/language/src/syntax_map/syntax_map_tests.rs b/crates/language/src/syntax_map/syntax_map_tests.rs index 0564856e433..b54609aef3c 100644 --- a/crates/language/src/syntax_map/syntax_map_tests.rs +++ b/crates/language/src/syntax_map/syntax_map_tests.rs @@ -481,6 +481,110 @@ fn test_rust_json_macro_empty_string_highlighting(cx: &mut App) { ); } +#[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( @@ -1930,12 +2034,16 @@ fn comment_lang() -> Language { ) } -/// Stands in for the real SQL language, which this crate doesn't depend on. The grammar -/// is irrelevant here; only the layers Python's injection query produces are asserted on. +/// 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()), @@ -1964,6 +2072,65 @@ fn range_for_text(buffer: &Buffer, text: &str) -> Range { 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> { + 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,