From 8e7fbcc131ec0f41cc4e78fbc8c50ef41f47b382 Mon Sep 17 00:00:00 2001 From: rn23thakur Date: Wed, 30 Sep 2026 20:34:35 +0000 Subject: [PATCH] language: Fix bracket `not_in` scopes being ignored at end of buffer (#64840) ## Summary "Closes #64820" Bracket `not_in` rules (like "don't auto-close `'` inside a comment") were ignored when the cursor was at the very end of the file. For example, in a C file containing only `// it ''`, typing `'` at EOF would still auto-insert a closing `'`, even though C disables that pair inside comments. The cause was in `language_scope_at` in `buffer.rs`. It walks down the syntax tree using `Range::contains`, which excludes the end of the range. At EOF, the cursor offset equals the end of the root node, so every layer got skipped. The function then fell back to a scope with no `override_id`, and all `not_in` rules were lost. The fix lets the tree walk accept the end of a node's range, but only when the cursor is at the end of the buffer. Behavior everywhere else in the file is unchanged. Huge thanks to @arixsnow who reported this in #64820 with clear repro steps and tracked the root cause. This PR implements the fix they pointed to. https://github.com/user-attachments/assets/dc3680c0-46f1-4fc1-b80a-973f18398139 ## Testing Ran `cargo test -p language`, all passed. The issue #64820 includes directions to reproduce it clearly I used the same to test the fix. ## Self-review - [x] I've reviewed my diff for quality, security, reliability, and performance. - [x] UI changes follow the [checklist](https://zed.dev/docs/development/ui-checklist). - [x] Tests cover the new or changed behavior. Release Notes: - Fixed auto-closing brackets being inserted inside comments or strings at the end of a file. --------- Co-authored-by: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> --- crates/language/src/buffer.rs | 7 ++- crates/language/src/buffer_tests.rs | 74 +++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+), 1 deletion(-) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 32b633d3e0d..c3e4030102f 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -4422,7 +4422,12 @@ impl BufferSnapshot { let mut range = None; loop { let child_range = cursor.node().byte_range(); - if !child_range.contains(&offset) { + let contains_offset = child_range.contains(&offset) + // `Range::contains` is end-exclusive, which rejects every node at EOF + // (including the root). Accept the end boundary only at the buffer's end, + // so mid-buffer behavior is unchanged. + || (child_range.end == offset && offset == text.len()); + if !contains_offset { break; } diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs index b3b2313aeb4..1f4f1348da8 100644 --- a/crates/language/src/buffer_tests.rs +++ b/crates/language/src/buffer_tests.rs @@ -3442,6 +3442,80 @@ fn test_language_scope_at_with_rust(cx: &mut App) { }); } +#[gpui::test] +fn test_language_scope_at_end_of_buffer(cx: &mut App) { + init_settings(cx, |_| {}); + + let make_language = || { + Language::new( + LanguageConfig { + name: "C".into(), + brackets: BracketPairConfig { + pairs: vec![ + BracketPair { + start: "{".into(), + end: "}".into(), + close: true, + surround: true, + newline: false, + }, + BracketPair { + start: "'".into(), + end: "'".into(), + close: true, + surround: true, + newline: false, + }, + ], + disabled_scopes_by_bracket_ix: vec![ + Vec::new(), + vec!["string".into(), "comment".into()], + ], + }, + ..Default::default() + }, + Some(tree_sitter_c::LANGUAGE.into()), + ) + .with_override_query( + r#" + (comment) @comment.inclusive + [(string_literal) (char_literal)] @string + "#, + ) + .unwrap() + }; + + // Comment runs to EOF: the quote pair must be disabled at EOF. + cx.new(|cx| { + let text = "// it ''"; + let buffer = Buffer::local(text, cx).with_language(Arc::new(make_language()), cx); + let snapshot = buffer.snapshot(); + + let eof_config = snapshot.language_scope_at(text.len()).unwrap(); + assert_eq!( + eof_config.brackets().map(|e| e.1).collect::>(), + &[true, false] + ); + + buffer + }); + + // Trailing newline: EOF is past the comment, so both pairs stay enabled. + cx.new(|cx| { + let text = "// it ''\n"; + let buffer = Buffer::local(text, cx).with_language(Arc::new(make_language()), cx); + let snapshot = buffer.snapshot(); + + let eof_config = snapshot.language_scope_at(text.len()).unwrap(); + assert_eq!( + eof_config.brackets().map(|e| e.1).collect::>(), + &[true, true] + ); + + buffer + }); +} + #[gpui::test] fn test_language_scope_at_with_combined_injections(cx: &mut App) { init_settings(cx, |_| {});