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.

rust: Refine sql! syntax injection (#58778)

Jung Woong Park14119f8d87b2
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<usize> {
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,