Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix a bunch of other low-hanging style lints (#36498)

Browse source 
- **Fix a bunch of low hanging style lints like unnecessary-return**
- **Fix single worktree violation**
- **And the rest**

Release Notes:

- N/A
This commit is contained in:
Piotr Osiewicz 2025-08-19 21:26:17 +02:00 • committed by GitHub
parent df9c2aefb1
commit 05fc0c432c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
239 changed files with 854 additions and 1015 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/editor/src/clangd_ext.rs
View file

@ -13,7 +13,7 @@ use crate::{Editor, SwitchSourceHeader, element::register_action};
use project::lsp_store::clangd_ext::CLANGD_SERVER_NAME;
fn is_c_language(language: &Language) -> bool {
return language.name() == "C++".into() || language.name() == "C".into();
language.name() == "C++".into() || language.name() == "C".into()
}
pub fn switch_source_header(

6
crates/editor/src/code_context_menus.rs
View file

@ -1111,10 +1111,8 @@ impl CompletionsMenu {
let query_start_doesnt_match_split_words = query_start_lower
.map(|query_char| {
!split_words(&string_match.string).any(|word| {
word.chars()
.next()
.and_then(|c| c.to_lowercase().next())
.map_or(false, |word_char| word_char == query_char)
word.chars().next().and_then(|c| c.to_lowercase().next())
== Some(query_char)
})
})
.unwrap_or(false);

2
crates/editor/src/display_map.rs
View file

@ -991,7 +991,7 @@ impl DisplaySnapshot {
if let Some(severity) = chunk.diagnostic_severity.filter(|severity| {
self.diagnostics_max_severity
.into_lsp()
.map_or(false, |max_severity| severity <= &max_severity)
.is_some_and(|max_severity| severity <= &max_severity)
}) {
if chunk.is_unnecessary {
diagnostic_highlight.fade_out = Some(editor_style.unnecessary_code_fade);

27
crates/editor/src/display_map/block_map.rs
View file

@ -528,10 +528,7 @@ impl BlockMap {
if let Some(transform) = cursor.item()
&& transform.summary.input_rows > 0
&& cursor.end() == old_start
&& transform
.block
.as_ref()
.map_or(true, |b| !b.is_replacement())
&& transform.block.as_ref().is_none_or(|b| !b.is_replacement())
{
// Preserve the transform (push and next)
new_transforms.push(transform.clone(), &());
@ -539,7 +536,7 @@ impl BlockMap {
// Preserve below blocks at end of edit
while let Some(transform) = cursor.item() {
if transform.block.as_ref().map_or(false, |b| b.place_below()) {
if transform.block.as_ref().is_some_and(|b| b.place_below()) {
new_transforms.push(transform.clone(), &());
cursor.next();
} else {
@ -606,7 +603,7 @@ impl BlockMap {
// Discard below blocks at the end of the edit. They'll be reconstructed.
while let Some(transform) = cursor.item() {
if transform.block.as_ref().map_or(false, |b| b.place_below()) {
if transform.block.as_ref().is_some_and(|b| b.place_below()) {
cursor.next();
} else {
break;
@ -1328,7 +1325,7 @@ impl BlockSnapshot {
let Dimensions(output_start, input_start, _) = cursor.start();
let overshoot = if cursor
.item()
.map_or(false, |transform| transform.block.is_none())
.is_some_and(|transform| transform.block.is_none())
{
start_row.0 - output_start.0
} else {
@ -1358,7 +1355,7 @@ impl BlockSnapshot {
&& transform
.block
.as_ref()
.map_or(false, |block| block.height() > 0))
.is_some_and(|block| block.height() > 0))
{
break;
}
@ -1511,7 +1508,7 @@ impl BlockSnapshot {
pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(&());
cursor.seek(&row, Bias::Right);
cursor.item().map_or(false, |t| t.block.is_some())
cursor.item().is_some_and(|t| t.block.is_some())
}
pub(super) fn is_folded_buffer_header(&self, row: BlockRow) -> bool {
@ -1529,11 +1526,11 @@ impl BlockSnapshot {
.make_wrap_point(Point::new(row.0, 0), Bias::Left);
let mut cursor = self.transforms.cursor::<Dimensions<WrapRow, BlockRow>>(&());
cursor.seek(&WrapRow(wrap_point.row()), Bias::Right);
cursor.item().map_or(false, |transform| {
cursor.item().is_some_and(|transform| {
transform
.block
.as_ref()
.map_or(false, |block| block.is_replacement())
.is_some_and(|block| block.is_replacement())
})
}
@ -1653,7 +1650,7 @@ impl BlockChunks<'_> {
if transform
.block
.as_ref()
.map_or(false, |block| block.height() == 0)
.is_some_and(|block| block.height() == 0)
{
self.transforms.next();
} else {
@ -1664,7 +1661,7 @@ impl BlockChunks<'_> {
if self
.transforms
.item()
.map_or(false, |transform| transform.block.is_none())
.is_some_and(|transform| transform.block.is_none())
{
let start_input_row = self.transforms.start().1.0;
let start_output_row = self.transforms.start().0.0;
@ -1774,7 +1771,7 @@ impl Iterator for BlockRows<'_> {
if transform
.block
.as_ref()
.map_or(false, |block| block.height() == 0)
.is_some_and(|block| block.height() == 0)
{
self.transforms.next();
} else {
@ -1786,7 +1783,7 @@ impl Iterator for BlockRows<'_> {
if transform
.block
.as_ref()
.map_or(true, |block| block.is_replacement())
.is_none_or(|block| block.is_replacement())
{
self.input_rows.seek(self.transforms.start().1.0);
}

22
crates/editor/src/display_map/fold_map.rs
View file

@ -491,14 +491,14 @@ impl FoldMap {
while folds
.peek()
.map_or(false, |(_, fold_range)| fold_range.start < edit.new.end)
.is_some_and(|(_, fold_range)| fold_range.start < edit.new.end)
{
let (fold, mut fold_range) = folds.next().unwrap();
let sum = new_transforms.summary();
assert!(fold_range.start.0 >= sum.input.len);
while folds.peek().map_or(false, |(next_fold, next_fold_range)| {
while folds.peek().is_some_and(|(next_fold, next_fold_range)| {
next_fold_range.start < fold_range.end
|| (next_fold_range.start == fold_range.end
&& fold.placeholder.merge_adjacent
@ -575,14 +575,14 @@ impl FoldMap {
for mut edit in inlay_edits {
old_transforms.seek(&edit.old.start, Bias::Left);
if old_transforms.item().map_or(false, |t| t.is_fold()) {
if old_transforms.item().is_some_and(|t| t.is_fold()) {
edit.old.start = old_transforms.start().0;
}
let old_start =
old_transforms.start().1.0 + (edit.old.start - old_transforms.start().0).0;
old_transforms.seek_forward(&edit.old.end, Bias::Right);
if old_transforms.item().map_or(false, |t| t.is_fold()) {
if old_transforms.item().is_some_and(|t| t.is_fold()) {
old_transforms.next();
edit.old.end = old_transforms.start().0;
}
@ -590,14 +590,14 @@ impl FoldMap {
old_transforms.start().1.0 + (edit.old.end - old_transforms.start().0).0;
new_transforms.seek(&edit.new.start, Bias::Left);
if new_transforms.item().map_or(false, |t| t.is_fold()) {
if new_transforms.item().is_some_and(|t| t.is_fold()) {
edit.new.start = new_transforms.start().0;
}
let new_start =
new_transforms.start().1.0 + (edit.new.start - new_transforms.start().0).0;
new_transforms.seek_forward(&edit.new.end, Bias::Right);
if new_transforms.item().map_or(false, |t| t.is_fold()) {
if new_transforms.item().is_some_and(|t| t.is_fold()) {
new_transforms.next();
edit.new.end = new_transforms.start().0;
}
@ -709,7 +709,7 @@ impl FoldSnapshot {
.transforms
.cursor::<Dimensions<InlayPoint, FoldPoint>>(&());
cursor.seek(&point, Bias::Right);
if cursor.item().map_or(false, |t| t.is_fold()) {
if cursor.item().is_some_and(|t| t.is_fold()) {
if bias == Bias::Left || point == cursor.start().0 {
cursor.start().1
} else {
@ -788,7 +788,7 @@ impl FoldSnapshot {
let inlay_offset = self.inlay_snapshot.to_inlay_offset(buffer_offset);
let mut cursor = self.transforms.cursor::<InlayOffset>(&());
cursor.seek(&inlay_offset, Bias::Right);
cursor.item().map_or(false, |t| t.placeholder.is_some())
cursor.item().is_some_and(|t| t.placeholder.is_some())
}
pub fn is_line_folded(&self, buffer_row: MultiBufferRow) -> bool {
@ -839,7 +839,7 @@ impl FoldSnapshot {
let inlay_end = if transform_cursor
.item()
.map_or(true, |transform| transform.is_fold())
.is_none_or(|transform| transform.is_fold())
{
inlay_start
} else if range.end < transform_end.0 {
@ -1348,7 +1348,7 @@ impl FoldChunks<'_> {
let inlay_end = if self
.transform_cursor
.item()
.map_or(true, |transform| transform.is_fold())
.is_none_or(|transform| transform.is_fold())
{
inlay_start
} else if range.end < transform_end.0 {
@ -1463,7 +1463,7 @@ impl FoldOffset {
.transforms
.cursor::<Dimensions<FoldOffset, TransformSummary>>(&());
cursor.seek(&self, Bias::Right);
let overshoot = if cursor.item().map_or(true, |t| t.is_fold()) {
let overshoot = if cursor.item().is_none_or(|t| t.is_fold()) {
Point::new(0, (self.0 - cursor.start().0.0) as u32)
} else {
let inlay_offset = cursor.start().1.input.len + self.0 - cursor.start().0.0;

2
crates/editor/src/display_map/inlay_map.rs
View file

@ -625,7 +625,7 @@ impl InlayMap {
// we can push its remainder.
if buffer_edits_iter
.peek()
.map_or(true, |edit| edit.old.start >= cursor.end().0)
.is_none_or(|edit| edit.old.start >= cursor.end().0)
{
let transform_start = new_transforms.summary().input.len;
let transform_end =

20
crates/editor/src/display_map/wrap_map.rs
View file

@ -74,10 +74,10 @@ impl WrapRows<'_> {
self.transforms
.seek(&WrapPoint::new(start_row, 0), Bias::Left);
let mut input_row = self.transforms.start().1.row();
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
input_row += start_row - self.transforms.start().0.row();
}
self.soft_wrapped = self.transforms.item().map_or(false, |t| !t.is_isomorphic());
self.soft_wrapped = self.transforms.item().is_some_and(|t| !t.is_isomorphic());
self.input_buffer_rows.seek(input_row);
self.input_buffer_row = self.input_buffer_rows.next().unwrap();
self.output_row = start_row;
@ -603,7 +603,7 @@ impl WrapSnapshot {
.cursor::<Dimensions<WrapPoint, TabPoint>>(&());
transforms.seek(&output_start, Bias::Right);
let mut input_start = TabPoint(transforms.start().1.0);
if transforms.item().map_or(false, |t| t.is_isomorphic()) {
if transforms.item().is_some_and(|t| t.is_isomorphic()) {
input_start.0 += output_start.0 - transforms.start().0.0;
}
let input_end = self
@ -634,7 +634,7 @@ impl WrapSnapshot {
cursor.seek(&WrapPoint::new(row + 1, 0), Bias::Left);
if cursor
.item()
.map_or(false, |transform| transform.is_isomorphic())
.is_some_and(|transform| transform.is_isomorphic())
{
let overshoot = row - cursor.start().0.row();
let tab_row = cursor.start().1.row() + overshoot;
@ -732,10 +732,10 @@ impl WrapSnapshot {
.cursor::<Dimensions<WrapPoint, TabPoint>>(&());
transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left);
let mut input_row = transforms.start().1.row();
if transforms.item().map_or(false, |t| t.is_isomorphic()) {
if transforms.item().is_some_and(|t| t.is_isomorphic()) {
input_row += start_row - transforms.start().0.row();
}
let soft_wrapped = transforms.item().map_or(false, |t| !t.is_isomorphic());
let soft_wrapped = transforms.item().is_some_and(|t| !t.is_isomorphic());
let mut input_buffer_rows = self.tab_snapshot.rows(input_row);
let input_buffer_row = input_buffer_rows.next().unwrap();
WrapRows {
@ -754,7 +754,7 @@ impl WrapSnapshot {
.cursor::<Dimensions<WrapPoint, TabPoint>>(&());
cursor.seek(&point, Bias::Right);
let mut tab_point = cursor.start().1.0;
if cursor.item().map_or(false, |t| t.is_isomorphic()) {
if cursor.item().is_some_and(|t| t.is_isomorphic()) {
tab_point += point.0 - cursor.start().0.0;
}
TabPoint(tab_point)
@ -780,7 +780,7 @@ impl WrapSnapshot {
if bias == Bias::Left {
let mut cursor = self.transforms.cursor::<WrapPoint>(&());
cursor.seek(&point, Bias::Right);
if cursor.item().map_or(false, |t| !t.is_isomorphic()) {
if cursor.item().is_some_and(|t| !t.is_isomorphic()) {
point = *cursor.start();
*point.column_mut() -= 1;
}
@ -901,7 +901,7 @@ impl WrapChunks<'_> {
let output_end = WrapPoint::new(rows.end, 0);
self.transforms.seek(&output_start, Bias::Right);
let mut input_start = TabPoint(self.transforms.start().1.0);
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
input_start.0 += output_start.0 - self.transforms.start().0.0;
}
let input_end = self
@ -993,7 +993,7 @@ impl Iterator for WrapRows<'_> {
self.output_row += 1;
self.transforms
.seek_forward(&WrapPoint::new(self.output_row, 0), Bias::Left);
if self.transforms.item().map_or(false, |t| t.is_isomorphic()) {
if self.transforms.item().is_some_and(|t| t.is_isomorphic()) {
self.input_buffer_row = self.input_buffer_rows.next().unwrap();
self.soft_wrapped = false;
} else {

111
crates/editor/src/editor.rs
View file

@ -1429,7 +1429,7 @@ impl SelectionHistory {
if self
.undo_stack
.back()
.map_or(true, |e| e.selections != entry.selections)
.is_none_or(|e| e.selections != entry.selections)
{
self.undo_stack.push_back(entry);
if self.undo_stack.len() > MAX_SELECTION_HISTORY_LEN {
@ -1442,7 +1442,7 @@ impl SelectionHistory {
if self
.redo_stack
.back()
.map_or(true, |e| e.selections != entry.selections)
.is_none_or(|e| e.selections != entry.selections)
{
self.redo_stack.push_back(entry);
if self.redo_stack.len() > MAX_SELECTION_HISTORY_LEN {
@ -2512,9 +2512,7 @@ impl Editor {
.context_menu
.borrow()
.as_ref()
.map_or(false, |context| {
matches!(context, CodeContextMenu::Completions(_))
});
.is_some_and(|context| matches!(context, CodeContextMenu::Completions(_)));
showing_completions
|| self.edit_prediction_requires_modifier()
@ -2545,7 +2543,7 @@ impl Editor {
|| binding
.keystrokes()
.first()
.map_or(false, |keystroke| keystroke.modifiers.modified())
.is_some_and(|keystroke| keystroke.modifiers.modified())
}))
}
@ -2941,7 +2939,7 @@ impl Editor {
return false;
};
scope.override_name().map_or(false, |scope_name| {
scope.override_name().is_some_and(|scope_name| {
settings
.edit_predictions_disabled_in
.iter()
@ -4033,18 +4031,18 @@ impl Editor {
let following_text_allows_autoclose = snapshot
.chars_at(selection.start)
.next()
.map_or(true, |c| scope.should_autoclose_before(c));
.is_none_or(|c| scope.should_autoclose_before(c));
let preceding_text_allows_autoclose = selection.start.column == 0
|| snapshot.reversed_chars_at(selection.start).next().map_or(
true,
|c| {
|| snapshot
.reversed_chars_at(selection.start)
.next()
.is_none_or(|c| {
bracket_pair.start != bracket_pair.end
|| !snapshot
.char_classifier_at(selection.start)
.is_word(c)
},
);
});
let is_closing_quote = if bracket_pair.end == bracket_pair.start
&& bracket_pair.start.len() == 1
@ -4185,7 +4183,7 @@ impl Editor {
if !self.linked_edit_ranges.is_empty() {
let start_anchor = snapshot.anchor_before(selection.start);
let is_word_char = text.chars().next().map_or(true, |char| {
let is_word_char = text.chars().next().is_none_or(|char| {
let classifier = snapshot
.char_classifier_at(start_anchor.to_offset(&snapshot))
.ignore_punctuation(true);
@ -5427,11 +5425,11 @@ impl Editor {
let sort_completions = provider
.as_ref()
.map_or(false, |provider| provider.sort_completions());
.is_some_and(|provider| provider.sort_completions());
let filter_completions = provider
.as_ref()
.map_or(true, |provider| provider.filter_completions());
.is_none_or(|provider| provider.filter_completions());
let trigger_kind = match trigger {
Some(trigger) if buffer.read(cx).completion_triggers().contains(trigger) => {
@ -5537,7 +5535,7 @@ impl Editor {
let skip_digits = query
.as_ref()
.map_or(true, |query| !query.chars().any(|c| c.is_digit(10)));
.is_none_or(|query| !query.chars().any(|c| c.is_digit(10)));
let (mut words, provider_responses) = match &provider {
Some(provider) => {
@ -5971,7 +5969,7 @@ impl Editor {
let show_new_completions_on_confirm = completion
.confirm
.as_ref()
.map_or(false, |confirm| confirm(intent, window, cx));
.is_some_and(|confirm| confirm(intent, window, cx));
if show_new_completions_on_confirm {
self.show_completions(&ShowCompletions { trigger: None }, window, cx);
}
@ -6103,10 +6101,10 @@ impl Editor {
let spawn_straight_away = quick_launch
&& resolved_tasks
.as_ref()
.map_or(false, |tasks| tasks.templates.len() == 1)
.is_some_and(|tasks| tasks.templates.len() == 1)
&& code_actions
.as_ref()
.map_or(true, |actions| actions.is_empty())
.is_none_or(|actions| actions.is_empty())
&& debug_scenarios.is_empty();
editor.update_in(cx, |editor, window, cx| {
@ -6720,9 +6718,9 @@ impl Editor {
let buffer_id = cursor_position.buffer_id;
let buffer = this.buffer.read(cx);
if !buffer
if buffer
.text_anchor_for_position(cursor_position, cx)
.map_or(false, |(buffer, _)| buffer == cursor_buffer)
.is_none_or(|(buffer, _)| buffer != cursor_buffer)
{
return;
}
@ -6972,9 +6970,7 @@ impl Editor {
|| self
.quick_selection_highlight_task
.as_ref()
.map_or(true, |(prev_anchor_range, _)| {
prev_anchor_range != &query_range
})
.is_none_or(|(prev_anchor_range, _)| prev_anchor_range != &query_range)
{
let multi_buffer_visible_start = self
.scroll_manager
@ -7003,9 +6999,7 @@ impl Editor {
|| self
.debounced_selection_highlight_task
.as_ref()
.map_or(true, |(prev_anchor_range, _)| {
prev_anchor_range != &query_range
})
.is_none_or(|(prev_anchor_range, _)| prev_anchor_range != &query_range)
{
let multi_buffer_start = multi_buffer_snapshot
.anchor_before(0)
@ -7140,9 +7134,7 @@ impl Editor {
&& self
.edit_prediction_provider
.as_ref()
.map_or(false, |provider| {
provider.provider.show_completions_in_menu()
});
.is_some_and(|provider| provider.provider.show_completions_in_menu());
let preview_requires_modifier =
all_language_settings(file, cx).edit_predictions_mode() == EditPredictionsMode::Subtle;
@ -7726,7 +7718,7 @@ impl Editor {
|| self
.active_edit_prediction
.as_ref()
.map_or(false, |completion| {
.is_some_and(|completion| {
let invalidation_range = completion.invalidation_range.to_offset(&multibuffer);
let invalidation_range = invalidation_range.start..=invalidation_range.end;
!invalidation_range.contains(&offset_selection.head())
@ -8427,7 +8419,7 @@ impl Editor {
.context_menu
.borrow()
.as_ref()
.map_or(false, |menu| menu.visible())
.is_some_and(|menu| menu.visible())
}
pub fn context_menu_origin(&self) -> Option<ContextMenuOrigin> {
@ -8973,9 +8965,8 @@ impl Editor {
let end_row = start_row + line_count as u32;
visible_row_range.contains(&start_row)
&& visible_row_range.contains(&end_row)
&& cursor_row.map_or(true, |cursor_row| {
!((start_row..end_row).contains(&cursor_row))
})
&& cursor_row
.is_none_or(|cursor_row| !((start_row..end_row).contains(&cursor_row)))
})?;
content_origin
@ -9585,7 +9576,7 @@ impl Editor {
.tabstops
.iter()
.map(|tabstop| {
let is_end_tabstop = tabstop.ranges.first().map_or(false, |tabstop| {
let is_end_tabstop = tabstop.ranges.first().is_some_and(|tabstop| {
tabstop.is_empty() && tabstop.start == snippet.text.len() as isize
});
let mut tabstop_ranges = tabstop
@ -11716,7 +11707,7 @@ impl Editor {
let transpose_start = display_map
.buffer_snapshot
.clip_offset(transpose_offset.saturating_sub(1), Bias::Left);
if edits.last().map_or(true, |e| e.0.end <= transpose_start) {
if edits.last().is_none_or(|e| e.0.end <= transpose_start) {
let transpose_end = display_map
.buffer_snapshot
.clip_offset(transpose_offset + 1, Bias::Right);
@ -16229,23 +16220,21 @@ impl Editor {
if split {
workspace.split_item(SplitDirection::Right, item.clone(), window, cx);
} else {
if PreviewTabsSettings::get_global(cx).enable_preview_from_code_navigation {
let (preview_item_id, preview_item_idx) =
workspace.active_pane().read_with(cx, |pane, _| {
(pane.preview_item_id(), pane.preview_item_idx())
});
} else if PreviewTabsSettings::get_global(cx).enable_preview_from_code_navigation {
let (preview_item_id, preview_item_idx) =
workspace.active_pane().read_with(cx, |pane, _| {
(pane.preview_item_id(), pane.preview_item_idx())
});
workspace.add_item_to_active_pane(item.clone(), preview_item_idx, true, window, cx);
workspace.add_item_to_active_pane(item.clone(), preview_item_idx, true, window, cx);
if let Some(preview_item_id) = preview_item_id {
workspace.active_pane().update(cx, |pane, cx| {
pane.remove_item(preview_item_id, false, false, window, cx);
});
}
} else {
workspace.add_item_to_active_pane(item.clone(), None, true, window, cx);
if let Some(preview_item_id) = preview_item_id {
workspace.active_pane().update(cx, |pane, cx| {
pane.remove_item(preview_item_id, false, false, window, cx);
});
}
} else {
workspace.add_item_to_active_pane(item.clone(), None, true, window, cx);
}
workspace.active_pane().update(cx, |pane, cx| {
pane.set_preview_item_id(Some(item_id), cx);
@ -19010,7 +18999,7 @@ impl Editor {
fn has_blame_entries(&self, cx: &App) -> bool {
self.blame()
.map_or(false, |blame| blame.read(cx).has_generated_entries())
.is_some_and(|blame| blame.read(cx).has_generated_entries())
}
fn newest_selection_head_on_empty_line(&self, cx: &App) -> bool {
@ -19660,7 +19649,7 @@ impl Editor {
pub fn has_background_highlights<T: 'static>(&self) -> bool {
self.background_highlights
.get(&HighlightKey::Type(TypeId::of::<T>()))
.map_or(false, |(_, highlights)| !highlights.is_empty())
.is_some_and(|(_, highlights)| !highlights.is_empty())
}
pub fn background_highlights_in_range(
@ -20582,7 +20571,7 @@ impl Editor {
// For now, don't allow opening excerpts in buffers that aren't backed by
// regular project files.
fn can_open_excerpts_in_file(file: Option<&Arc<dyn language::File>>) -> bool {
file.map_or(true, |file| project::File::from_dyn(Some(file)).is_some())
file.is_none_or(|file| project::File::from_dyn(Some(file)).is_some())
}
fn marked_text_ranges(&self, cx: &App) -> Option<Vec<Range<OffsetUtf16>>> {
@ -21125,7 +21114,7 @@ impl Editor {
pub fn has_visible_completions_menu(&self) -> bool {
!self.edit_prediction_preview_is_active()
&& self.context_menu.borrow().as_ref().map_or(false, |menu| {
&& self.context_menu.borrow().as_ref().is_some_and(|menu| {
menu.visible() && matches!(menu, CodeContextMenu::Completions(_))
})
}
@ -21548,9 +21537,9 @@ fn is_grapheme_whitespace(text: &str) -> bool {
}
fn should_stay_with_preceding_ideograph(text: &str) -> bool {
text.chars().next().map_or(false, |ch| {
matches!(ch, '。' | '、' | '，' | '？' | '！' | '：' | '；' | '…')
})
text.chars()
.next()
.is_some_and(|ch| matches!(ch, '。' | '、' | '，' | '？' | '！' | '：' | '；' | '…'))
}
#[derive(PartialEq, Eq, Debug, Clone, Copy)]
@ -21589,11 +21578,11 @@ impl<'a> Iterator for WordBreakingTokenizer<'a> {
} else {
let mut words = self.input[offset..].split_word_bound_indices().peekable();
let mut next_word_bound = words.peek().copied();
if next_word_bound.map_or(false, |(i, _)| i == 0) {
if next_word_bound.is_some_and(|(i, _)| i == 0) {
next_word_bound = words.next();
}
while let Some(grapheme) = iter.peek().copied() {
if next_word_bound.map_or(false, |(i, _)| i == offset) {
if next_word_bound.is_some_and(|(i, _)| i == offset) {
break;
};
if is_grapheme_whitespace(grapheme) != is_whitespace

6
crates/editor/src/editor_settings.rs
View file

@ -810,10 +810,8 @@ impl Settings for EditorSettings {
if gutter.line_numbers.is_some() {
old_gutter.line_numbers = gutter.line_numbers
}
} else {
if gutter != GutterContent::default() {
current.gutter = Some(gutter)
}
} else if gutter != GutterContent::default() {
current.gutter = Some(gutter)
}
if let Some(b) = vscode.read_bool("editor.scrollBeyondLastLine") {
current.scroll_beyond_last_line = Some(if b {

120
crates/editor/src/element.rs
View file

@ -919,6 +919,7 @@ impl EditorElement {
{
#[allow(
clippy::collapsible_if,
clippy::needless_return,
reason = "The cfg-block below makes this a false positive"
)]
if !text_hitbox.is_hovered(window) || editor.read_only(cx) {
@ -1126,26 +1127,24 @@ impl EditorElement {
let hovered_diff_hunk_row = if let Some(control_row) = hovered_diff_control {
Some(control_row)
} else {
if text_hovered {
let current_row = valid_point.row();
position_map.display_hunks.iter().find_map(|(hunk, _)| {
if let DisplayDiffHunk::Unfolded {
display_row_range, ..
} = hunk
{
if display_row_range.contains(&current_row) {
Some(display_row_range.start)
} else {
None
}
} else if text_hovered {
let current_row = valid_point.row();
position_map.display_hunks.iter().find_map(|(hunk, _)| {
if let DisplayDiffHunk::Unfolded {
display_row_range, ..
} = hunk
{
if display_row_range.contains(&current_row) {
Some(display_row_range.start)
} else {
None
}
})
} else {
None
}
} else {
None
}
})
} else {
None
};
if hovered_diff_hunk_row != editor.hovered_diff_hunk_row {
@ -1159,11 +1158,11 @@ impl EditorElement {
.inline_blame_popover
.as_ref()
.and_then(|state| state.popover_bounds)
.map_or(false, |bounds| bounds.contains(&event.position));
.is_some_and(|bounds| bounds.contains(&event.position));
let keyboard_grace = editor
.inline_blame_popover
.as_ref()
.map_or(false, |state| state.keyboard_grace);
.is_some_and(|state| state.keyboard_grace);
if mouse_over_inline_blame || mouse_over_popover {
editor.show_blame_popover(blame_entry, event.position, false, cx);
@ -1190,10 +1189,10 @@ impl EditorElement {
let is_visible = editor
.gutter_breakpoint_indicator
.0
.map_or(false, |indicator| indicator.is_active);
.is_some_and(|indicator| indicator.is_active);
let has_existing_breakpoint =
editor.breakpoint_store.as_ref().map_or(false, |store| {
editor.breakpoint_store.as_ref().is_some_and(|store| {
let Some(project) = &editor.project else {
return false;
};
@ -2220,12 +2219,11 @@ impl EditorElement {
cmp::max(padded_line, min_start)
};
let behind_edit_prediction_popover = edit_prediction_popover_origin.as_ref().map_or(
false,
|edit_prediction_popover_origin| {
let behind_edit_prediction_popover = edit_prediction_popover_origin
.as_ref()
.is_some_and(|edit_prediction_popover_origin| {
(pos_y..pos_y + line_height).contains(&edit_prediction_popover_origin.y)
},
);
});
let opacity = if behind_edit_prediction_popover {
0.5
} else {
@ -2291,9 +2289,7 @@ impl EditorElement {
None
}
})
.map_or(false, |source| {
matches!(source, CodeActionSource::Indicator(..))
});
.is_some_and(|source| matches!(source, CodeActionSource::Indicator(..)));
Some(editor.render_inline_code_actions(icon_size, display_point.row(), active, cx))
})?;
@ -2909,7 +2905,7 @@ impl EditorElement {
if multibuffer_row
.0
.checked_sub(1)
.map_or(false, |previous_row| {
.is_some_and(|previous_row| {
snapshot.is_line_folded(MultiBufferRow(previous_row))
})
{
@ -3900,7 +3896,7 @@ impl EditorElement {
for (row, block) in fixed_blocks {
let block_id = block.id();
if focused_block.as_ref().map_or(false, |b| b.id == block_id) {
if focused_block.as_ref().is_some_and(|b| b.id == block_id) {
focused_block = None;
}
@ -3957,7 +3953,7 @@ impl EditorElement {
};
let block_id = block.id();
if focused_block.as_ref().map_or(false, |b| b.id == block_id) {
if focused_block.as_ref().is_some_and(|b| b.id == block_id) {
focused_block = None;
}
@ -4736,7 +4732,7 @@ impl EditorElement {
}
};
let source_included = source_display_point.map_or(true, |source_display_point| {
let source_included = source_display_point.is_none_or(|source_display_point| {
visible_range
.to_inclusive()
.contains(&source_display_point.row())
@ -4916,7 +4912,7 @@ impl EditorElement {
let intersects_menu = |bounds: Bounds<Pixels>| -> bool {
context_menu_layout
.as_ref()
.map_or(false, |menu| bounds.intersects(&menu.bounds))
.is_some_and(|menu| bounds.intersects(&menu.bounds))
};
let can_place_above = {
@ -5101,7 +5097,7 @@ impl EditorElement {
if active_positions
.iter()
.any(|p| p.map_or(false, |p| display_row_range.contains(&p.row())))
.any(|p| p.is_some_and(|p| display_row_range.contains(&p.row())))
{
let y = display_row_range.start.as_f32() * line_height
+ text_hitbox.bounds.top()
@ -5214,7 +5210,7 @@ impl EditorElement {
let intersects_menu = |bounds: Bounds<Pixels>| -> bool {
context_menu_layout
.as_ref()
.map_or(false, |menu| bounds.intersects(&menu.bounds))
.is_some_and(|menu| bounds.intersects(&menu.bounds))
};
let final_origin = if popover_bounds_above.is_contained_within(hitbox)
@ -5299,7 +5295,7 @@ impl EditorElement {
let mut end_row = start_row.0;
while active_rows
.peek()
.map_or(false, |(active_row, has_selection)| {
.is_some_and(|(active_row, has_selection)| {
active_row.0 == end_row + 1
&& has_selection.selection == contains_non_empty_selection.selection
})
@ -6687,25 +6683,23 @@ impl EditorElement {
editor.set_scroll_position(position, window, cx);
}
cx.stop_propagation();
} else {
if minimap_hitbox.is_hovered(window) {
editor.scroll_manager.set_is_hovering_minimap_thumb(
!event.dragging()
&& layout
.thumb_layout
.thumb_bounds
.is_some_and(|bounds| bounds.contains(&event.position)),
cx,
);
} else if minimap_hitbox.is_hovered(window) {
editor.scroll_manager.set_is_hovering_minimap_thumb(
!event.dragging()
&& layout
.thumb_layout
.thumb_bounds
.is_some_and(|bounds| bounds.contains(&event.position)),
cx,
);
// Stop hover events from propagating to the
// underlying editor if the minimap hitbox is hovered
if !event.dragging() {
cx.stop_propagation();
}
} else {
editor.scroll_manager.hide_minimap_thumb(cx);
// Stop hover events from propagating to the
// underlying editor if the minimap hitbox is hovered
if !event.dragging() {
cx.stop_propagation();
}
} else {
editor.scroll_manager.hide_minimap_thumb(cx);
}
mouse_position = event.position;
});
@ -7084,9 +7078,7 @@ impl EditorElement {
let unstaged_hollow = ProjectSettings::get_global(cx)
.git
.hunk_style
.map_or(false, |style| {
matches!(style, GitHunkStyleSetting::UnstagedHollow)
});
.is_some_and(|style| matches!(style, GitHunkStyleSetting::UnstagedHollow));
unstaged == unstaged_hollow
}
@ -8183,7 +8175,7 @@ impl Element for EditorElement {
let is_row_soft_wrapped = |row: usize| {
row_infos
.get(row)
.map_or(true, |info| info.buffer_row.is_none())
.is_none_or(|info| info.buffer_row.is_none())
};
let start_anchor = if start_row == Default::default() {
@ -9718,14 +9710,12 @@ impl PointForPosition {
false
} else if start_row == end_row {
candidate_col >= start_col && candidate_col < end_col
} else if candidate_row == start_row {
candidate_col >= start_col
} else if candidate_row == end_row {
candidate_col < end_col
} else {
if candidate_row == start_row {
candidate_col >= start_col
} else if candidate_row == end_row {
candidate_col < end_col
} else {
true
}
true
}
}
}

2
crates/editor/src/git/blame.rs
View file

@ -415,7 +415,7 @@ impl GitBlame {
let old_end = cursor.end();
if row_edits
.peek()
.map_or(true, |next_edit| next_edit.old.start >= old_end)
.is_none_or(|next_edit| next_edit.old.start >= old_end)
&& let Some(entry) = cursor.item()
{
if old_end > edit.old.end {

4
crates/editor/src/hover_links.rs
View file

@ -271,7 +271,7 @@ impl Editor {
Task::ready(Ok(Navigated::No))
};
self.select(SelectPhase::End, window, cx);
return navigate_task;
navigate_task
}
}
@ -871,7 +871,7 @@ fn surrounding_filename(
.peekable();
while let Some(ch) = forwards.next() {
// Skip escaped whitespace
if ch == '\\' && forwards.peek().map_or(false, |ch| ch.is_whitespace()) {
if ch == '\\' && forwards.peek().is_some_and(|ch| ch.is_whitespace()) {
token_end += ch.len_utf8();
let whitespace = forwards.next().unwrap();
token_end += whitespace.len_utf8();

4
crates/editor/src/items.rs
View file

@ -201,7 +201,7 @@ impl FollowableItem for Editor {
if buffer
.as_singleton()
.and_then(|buffer| buffer.read(cx).file())
.map_or(false, |file| file.is_private())
.is_some_and(|file| file.is_private())
{
return None;
}
@ -715,7 +715,7 @@ impl Item for Editor {
.read(cx)
.as_singleton()
.and_then(|buffer| buffer.read(cx).file())
.map_or(false, |file| file.disk_state() == DiskState::Deleted);
.is_some_and(|file| file.disk_state() == DiskState::Deleted);
h_flex()
.gap_2()

24
crates/editor/src/jsx_tag_auto_close.rs
View file

@ -86,9 +86,9 @@ pub(crate) fn should_auto_close(
});
}
if to_auto_edit.is_empty() {
return None;
None
} else {
return Some(to_auto_edit);
Some(to_auto_edit)
}
}
@ -186,7 +186,7 @@ pub(crate) fn generate_auto_close_edits(
let range = node_name.byte_range();
return buffer.text_for_range(range).equals_str(name);
}
return is_empty;
is_empty
};
let tree_root_node = {
@ -227,7 +227,7 @@ pub(crate) fn generate_auto_close_edits(
let has_open_tag_with_same_tag_name = ancestor
.named_child(0)
.filter(|n| n.kind() == config.open_tag_node_name)
.map_or(false, |element_open_tag_node| {
.is_some_and(|element_open_tag_node| {
tag_node_name_equals(&element_open_tag_node, &tag_name)
});
if has_open_tag_with_same_tag_name {
@ -263,8 +263,7 @@ pub(crate) fn generate_auto_close_edits(
}
let is_after_open_tag = |node: &Node| {
return node.start_byte() < open_tag.start_byte()
&& node.end_byte() < open_tag.start_byte();
node.start_byte() < open_tag.start_byte() && node.end_byte() < open_tag.start_byte()
};
// perf: use cursor for more efficient traversal
@ -301,7 +300,7 @@ pub(crate) fn generate_auto_close_edits(
let edit_range = edit_anchor..edit_anchor;
edits.push((edit_range, format!("</{}>", tag_name)));
}
return Ok(edits);
Ok(edits)
}
pub(crate) fn refresh_enabled_in_any_buffer(
@ -367,7 +366,7 @@ pub(crate) fn construct_initial_buffer_versions_map<
initial_buffer_versions.insert(buffer_id, buffer_version);
}
}
return initial_buffer_versions;
initial_buffer_versions
}
pub(crate) fn handle_from(
@ -455,12 +454,9 @@ pub(crate) fn handle_from(
let ensure_no_edits_since_start = || -> Option<()> {
let has_edits_since_start = this
.read_with(cx, |this, cx| {
this.buffer
.read(cx)
.buffer(buffer_id)
.map_or(true, |buffer| {
buffer.read(cx).has_edits_since(&buffer_version_initial)
})
this.buffer.read(cx).buffer(buffer_id).is_none_or(|buffer| {
buffer.read(cx).has_edits_since(&buffer_version_initial)
})
})
.ok()?;

4
crates/editor/src/mouse_context_menu.rs
View file

@ -61,13 +61,13 @@ impl MouseContextMenu {
source,
offset: position - (source_position + content_origin),
};
return Some(MouseContextMenu::new(
Some(MouseContextMenu::new(
editor,
menu_position,
context_menu,
window,
cx,
));
))
}
pub(crate) fn new(

2
crates/editor/src/tasks.rs
View file

@ -89,7 +89,7 @@ impl Editor {
.lsp_task_source()?;
if lsp_settings
.get(&lsp_tasks_source)
.map_or(true, |s| s.enable_lsp_tasks)
.is_none_or(|s| s.enable_lsp_tasks)
{
let buffer_id = buffer.read(cx).remote_id();
Some((lsp_tasks_source, buffer_id))