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>
This commit is contained in:
rn23thakur
2026-09-30 20:34:35 +00:00
committed by GitHub
parent 0bdc70c2eb
commit 8e7fbcc131
2 changed files with 80 additions and 1 deletions
+6 -1
View File
@@ -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;
}
+74
View File
@@ -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::<Vec<_>>(),
&[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::<Vec<_>>(),
&[true, true]
);
buffer
});
}
#[gpui::test]
fn test_language_scope_at_with_combined_injections(cx: &mut App) {
init_settings(cx, |_| {});