1
Fork 0

Run clippy --fix for unnecessary_map_or lint

This commit is contained in:
Yotam Ofek 2025-01-19 19:15:00 +00:00
parent 39dc268459
commit 264fa0fc54
39 changed files with 61 additions and 67 deletions

View file

@ -72,7 +72,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
if let Some(local_sig_id) = def_id.as_local() { if let Some(local_sig_id) = def_id.as_local() {
// The value may be missing due to recursive delegation. // The value may be missing due to recursive delegation.
// Error will be emitted later during HIR ty lowering. // Error will be emitted later during HIR ty lowering.
self.resolver.delegation_fn_sigs.get(&local_sig_id).map_or(false, |sig| sig.has_self) self.resolver.delegation_fn_sigs.get(&local_sig_id).is_some_and(|sig| sig.has_self)
} else { } else {
match self.tcx.def_kind(def_id) { match self.tcx.def_kind(def_id) {
DefKind::Fn => false, DefKind::Fn => false,

View file

@ -83,7 +83,7 @@ impl<'a> PostExpansionVisitor<'a> {
feature_err_issue(&self.sess, feature, span, GateIssue::Language, explain).emit(); feature_err_issue(&self.sess, feature, span, GateIssue::Language, explain).emit();
} }
Err(abi::AbiDisabled::Unrecognized) => { Err(abi::AbiDisabled::Unrecognized) => {
if self.sess.opts.pretty.map_or(true, |ppm| ppm.needs_hir()) { if self.sess.opts.pretty.is_none_or(|ppm| ppm.needs_hir()) {
self.sess.dcx().span_delayed_bug( self.sess.dcx().span_delayed_bug(
span, span,
format!( format!(

View file

@ -166,7 +166,7 @@ pub fn parse_repr_attr(sess: &Session, attr: &impl AttributeExt) -> Vec<ReprAttr
// the `check_mod_attrs` pass, but this pass doesn't always run // the `check_mod_attrs` pass, but this pass doesn't always run
// (e.g. if we only pretty-print the source), so we have to gate // (e.g. if we only pretty-print the source), so we have to gate
// the `span_delayed_bug` call as follows: // the `span_delayed_bug` call as follows:
if sess.opts.pretty.map_or(true, |pp| pp.needs_analysis()) { if sess.opts.pretty.is_none_or(|pp| pp.needs_analysis()) {
dcx.span_delayed_bug(item.span(), "unrecognized representation hint"); dcx.span_delayed_bug(item.span(), "unrecognized representation hint");
} }
} }

View file

@ -2480,7 +2480,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
// To support cases like `|| { v.call(|this| v.get()) }` // To support cases like `|| { v.call(|this| v.get()) }`
// FIXME: actually support such cases (need to figure out how to move from the // FIXME: actually support such cases (need to figure out how to move from the
// capture place to original local). // capture place to original local).
&& self.res.as_ref().map_or(true, |(prev_res, _)| prev_res.span.contains(ex.span)) && self.res.as_ref().is_none_or(|(prev_res, _)| prev_res.span.contains(ex.span))
{ {
self.res = Some((ex, closure)); self.res = Some((ex, closure));
} }

View file

@ -131,10 +131,10 @@ impl<'tcx> BorrowExplanation<'tcx> {
&& let Ok(pat) = tcx.sess.source_map().span_to_snippet(pat.span) && let Ok(pat) = tcx.sess.source_map().span_to_snippet(pat.span)
{ {
suggest_rewrite_if_let(tcx, expr, &pat, init, conseq, alt, err); suggest_rewrite_if_let(tcx, expr, &pat, init, conseq, alt, err);
} else if path_span.map_or(true, |path_span| path_span == var_or_use_span) { } else if path_span.is_none_or(|path_span| path_span == var_or_use_span) {
// We can use `var_or_use_span` if either `path_span` is not present, or both // We can use `var_or_use_span` if either `path_span` is not present, or both
// spans are the same. // spans are the same.
if borrow_span.map_or(true, |sp| !sp.overlaps(var_or_use_span)) { if borrow_span.is_none_or(|sp| !sp.overlaps(var_or_use_span)) {
err.span_label( err.span_label(
var_or_use_span, var_or_use_span,
format!("{borrow_desc}borrow later {message}"), format!("{borrow_desc}borrow later {message}"),

View file

@ -442,7 +442,7 @@ pub(crate) fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) ->
// (or if there is no allocator argument). // (or if there is no allocator argument).
ty::Adt(def, args) ty::Adt(def, args)
if def.is_box() if def.is_box()
&& args.get(1).map_or(true, |arg| cx.layout_of(arg.expect_ty()).is_1zst()) => && args.get(1).is_none_or(|arg| cx.layout_of(arg.expect_ty()).is_1zst()) =>
{ {
build_pointer_or_reference_di_node(cx, t, t.expect_boxed_ty(), unique_type_id) build_pointer_or_reference_di_node(cx, t, t.expect_boxed_ty(), unique_type_id)
} }

View file

@ -3146,7 +3146,7 @@ impl FileWithAnnotatedLines {
add_annotation_to_file(&mut output, Lrc::clone(&file), line, ann.as_line()); add_annotation_to_file(&mut output, Lrc::clone(&file), line, ann.as_line());
} }
let line_end = ann.line_end - 1; let line_end = ann.line_end - 1;
let end_is_empty = file.get_line(line_end - 1).map_or(false, |s| !filter(&s)); let end_is_empty = file.get_line(line_end - 1).is_some_and(|s| !filter(&s));
if middle < line_end && !end_is_empty { if middle < line_end && !end_is_empty {
add_annotation_to_file(&mut output, Lrc::clone(&file), line_end, ann.as_line()); add_annotation_to_file(&mut output, Lrc::clone(&file), line_end, ann.as_line());
} }

View file

@ -463,7 +463,7 @@ impl DiagnosticSpan {
// is an empty string, increase the length to include the newline so we don't // is an empty string, increase the length to include the newline so we don't
// leave an empty line // leave an empty line
if start.col.0 == 0 if start.col.0 == 0
&& suggestion.map_or(false, |(s, _)| s.is_empty()) && suggestion.is_some_and(|(s, _)| s.is_empty())
&& let Ok(after) = je.sm.span_to_next_source(span) && let Ok(after) = je.sm.span_to_next_source(span)
&& after.starts_with('\n') && after.starts_with('\n')
{ {

View file

@ -1717,7 +1717,7 @@ impl DiagCtxtInner {
let bugs: Vec<_> = let bugs: Vec<_> =
std::mem::take(&mut self.delayed_bugs).into_iter().map(|(b, _)| b).collect(); std::mem::take(&mut self.delayed_bugs).into_iter().map(|(b, _)| b).collect();
let backtrace = std::env::var_os("RUST_BACKTRACE").map_or(true, |x| &x != "0"); let backtrace = std::env::var_os("RUST_BACKTRACE").is_none_or(|x| &x != "0");
let decorate = backtrace || self.ice_file.is_none(); let decorate = backtrace || self.ice_file.is_none();
let mut out = self let mut out = self
.ice_file .ice_file

View file

@ -391,7 +391,7 @@ impl<'a> StripUnconfigured<'a> {
validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item); validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item);
( (
parse_cfg(&meta_item, self.sess).map_or(true, |meta_item| { parse_cfg(&meta_item, self.sess).is_none_or(|meta_item| {
attr::cfg_matches(meta_item, &self.sess, self.lint_node_id, self.features) attr::cfg_matches(meta_item, &self.sess, self.lint_node_id, self.features)
}), }),
Some(meta_item), Some(meta_item),

View file

@ -159,7 +159,7 @@ impl<'dcx, 'matcher> Tracker<'matcher> for CollectTrackerAndEmitter<'dcx, 'match
if self if self
.best_failure .best_failure
.as_ref() .as_ref()
.map_or(true, |failure| failure.is_better_position(*approx_position)) .is_none_or(|failure| failure.is_better_position(*approx_position))
{ {
self.best_failure = Some(BestFailure { self.best_failure = Some(BestFailure {
token: token.clone(), token: token.clone(),

View file

@ -794,7 +794,7 @@ impl<Id> Res<Id> {
/// Always returns `true` if `self` is `Res::Err` /// Always returns `true` if `self` is `Res::Err`
pub fn matches_ns(&self, ns: Namespace) -> bool { pub fn matches_ns(&self, ns: Namespace) -> bool {
self.ns().map_or(true, |actual_ns| actual_ns == ns) self.ns().is_none_or(|actual_ns| actual_ns == ns)
} }
/// Returns whether such a resolved path can occur in a tuple struct/variant pattern /// Returns whether such a resolved path can occur in a tuple struct/variant pattern

View file

@ -1210,7 +1210,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// - foo((), "current", 42u32, "next") // - foo((), "current", 42u32, "next")
// + foo((), 42u32) // + foo((), 42u32)
{ {
prev_extra_idx.map_or(true, |prev_extra_idx| { prev_extra_idx.is_none_or(|prev_extra_idx| {
prev_extra_idx + 1 == arg_idx.index() prev_extra_idx + 1 == arg_idx.index()
}) })
} }

View file

@ -1143,7 +1143,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.may_coerce(found, ty) self.may_coerce(found, ty)
} }
hir::FnRetTy::DefaultReturn(_) if in_closure => { hir::FnRetTy::DefaultReturn(_) if in_closure => {
self.ret_coercion.as_ref().map_or(false, |ret| { self.ret_coercion.as_ref().is_some_and(|ret| {
let ret_ty = ret.borrow().expected_ty(); let ret_ty = ret.borrow().expected_ty();
self.may_coerce(found, ret_ty) self.may_coerce(found, ret_ty)
}) })
@ -1784,14 +1784,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let results = self.typeck_results.borrow(); let results = self.typeck_results.borrow();
// First, look for a `Clone::clone` call // First, look for a `Clone::clone` call
if segment.ident.name == sym::clone if segment.ident.name == sym::clone
&& results.type_dependent_def_id(expr.hir_id).map_or( && results.type_dependent_def_id(expr.hir_id).is_some_and(|did| {
false,
|did| {
let assoc_item = self.tcx.associated_item(did); let assoc_item = self.tcx.associated_item(did);
assoc_item.container == ty::AssocItemContainer::Trait assoc_item.container == ty::AssocItemContainer::Trait
&& assoc_item.container_id(self.tcx) == clone_trait_did && assoc_item.container_id(self.tcx) == clone_trait_did
}, })
)
// If that clone call hasn't already dereferenced the self type (i.e. don't give this // If that clone call hasn't already dereferenced the self type (i.e. don't give this
// diagnostic in cases where we have `(&&T).clone()` and we expect `T`). // diagnostic in cases where we have `(&&T).clone()` and we expect `T`).
&& !results.expr_adjustments(callee_expr).iter().any(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(..))) && !results.expr_adjustments(callee_expr).iter().any(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(..)))

View file

@ -3761,18 +3761,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
hir::TraitFn::Required([ident, ..]) => { hir::TraitFn::Required([ident, ..]) => {
ident.name == kw::SelfLower ident.name == kw::SelfLower
} }
hir::TraitFn::Provided(body_id) => { hir::TraitFn::Provided(body_id) => self
self.tcx.hir().body(*body_id).params.first().map_or( .tcx
false, .hir()
|param| { .body(*body_id)
matches!( .params
param.pat.kind, .first()
hir::PatKind::Binding(_, _, ident, _) .is_some_and(|param| {
if ident.name == kw::SelfLower matches!(
) param.pat.kind,
}, hir::PatKind::Binding(_, _, ident, _)
) if ident.name == kw::SelfLower
} )
}),
_ => false, _ => false,
}; };

View file

@ -258,7 +258,7 @@ impl<I: Idx> IntervalSet<I> {
} }
current = Some(*end); current = Some(*end);
} }
current.map_or(true, |x| x < self.domain as u32) current.is_none_or(|x| x < self.domain as u32)
} }
} }

View file

@ -57,7 +57,7 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
let expect_id = canonicalize_id(expect_id); let expect_id = canonicalize_id(expect_id);
if !fulfilled_expectations.contains(&expect_id) if !fulfilled_expectations.contains(&expect_id)
&& tool_filter.map_or(true, |filter| expectation.lint_tool == Some(filter)) && tool_filter.is_none_or(|filter| expectation.lint_tool == Some(filter))
{ {
let rationale = expectation.reason.map(|rationale| ExpectationNote { rationale }); let rationale = expectation.reason.map(|rationale| ExpectationNote { rationale });
let note = expectation.is_unfulfilled_lint_expectations; let note = expectation.is_unfulfilled_lint_expectations;

View file

@ -417,7 +417,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
// Any descendants of `std` should be private. These crates are usually not marked // Any descendants of `std` should be private. These crates are usually not marked
// private in metadata, so we ignore that field. // private in metadata, so we ignore that field.
if extern_private.is_none() if extern_private.is_none()
&& dep_root.map_or(false, |d| STDLIB_STABLE_CRATES.contains(&d.name)) && dep_root.is_some_and(|d| STDLIB_STABLE_CRATES.contains(&d.name))
{ {
return true; return true;
} }

View file

@ -97,7 +97,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
debug_assert!(prov.len() <= 1); debug_assert!(prov.len() <= 1);
if let Some(entry) = prov.first() { if let Some(entry) = prov.first() {
// If it overlaps with this byte, it is on this byte. // If it overlaps with this byte, it is on this byte.
debug_assert!(self.bytes.as_ref().map_or(true, |b| b.get(&offset).is_none())); debug_assert!(self.bytes.as_ref().is_none_or(|b| b.get(&offset).is_none()));
Some(entry.1) Some(entry.1)
} else { } else {
// Look up per-byte provenance. // Look up per-byte provenance.
@ -301,7 +301,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
// For really small copies, make sure we don't start before `src` does. // For really small copies, make sure we don't start before `src` does.
let entry_start = cmp::max(entry.0, src.start); let entry_start = cmp::max(entry.0, src.start);
for offset in entry_start..src.end() { for offset in entry_start..src.end() {
if bytes.last().map_or(true, |bytes_entry| bytes_entry.0 < offset) { if bytes.last().is_none_or(|bytes_entry| bytes_entry.0 < offset) {
// The last entry, if it exists, has a lower offset than us. // The last entry, if it exists, has a lower offset than us.
bytes.push((offset, entry.1)); bytes.push((offset, entry.1));
} else { } else {

View file

@ -433,7 +433,7 @@ pub fn analyze_coroutine_closure_captures<'a, 'tcx: 'a, T>(
// A parent matches a child if they share the same prefix of projections. // A parent matches a child if they share the same prefix of projections.
// The child may have more, if it is capturing sub-fields out of // The child may have more, if it is capturing sub-fields out of
// something that is captured by-move in the parent closure. // something that is captured by-move in the parent closure.
while child_captures.peek().map_or(false, |(_, child_capture)| { while child_captures.peek().is_some_and(|(_, child_capture)| {
child_prefix_matches_parent_projections(parent_capture, child_capture) child_prefix_matches_parent_projections(parent_capture, child_capture)
}) { }) {
let (child_field_idx, child_capture) = child_captures.next().unwrap(); let (child_field_idx, child_capture) = child_captures.next().unwrap();

View file

@ -328,7 +328,7 @@ impl<'tcx> InstanceKind<'tcx> {
// We include enums without destructors to allow, say, optimizing // We include enums without destructors to allow, say, optimizing
// drops of `Option::None` before LTO. We also respect the intent of // drops of `Option::None` before LTO. We also respect the intent of
// `#[inline]` on `Drop::drop` implementations. // `#[inline]` on `Drop::drop` implementations.
return ty.ty_adt_def().map_or(true, |adt_def| { return ty.ty_adt_def().is_none_or(|adt_def| {
match *self { match *self {
ty::InstanceKind::DropGlue(..) => adt_def.destructor(tcx).map(|dtor| dtor.did), ty::InstanceKind::DropGlue(..) => adt_def.destructor(tcx).map(|dtor| dtor.did),
ty::InstanceKind::AsyncDropGlueCtorShim(..) => { ty::InstanceKind::AsyncDropGlueCtorShim(..) => {

View file

@ -1894,11 +1894,11 @@ impl<'tcx> Ty<'tcx> {
ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false, ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
ty::Tuple(tys) => tys.last().map_or(true, |ty| ty.is_trivially_sized(tcx)), ty::Tuple(tys) => tys.last().is_none_or(|ty| ty.is_trivially_sized(tcx)),
ty::Adt(def, args) => def ty::Adt(def, args) => def
.sized_constraint(tcx) .sized_constraint(tcx)
.map_or(true, |ty| ty.instantiate(tcx, args).is_trivially_sized(tcx)), .is_none_or(|ty| ty.instantiate(tcx, args).is_trivially_sized(tcx)),
ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) | ty::Bound(..) => false, ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) | ty::Bound(..) => false,

View file

@ -360,7 +360,7 @@ fn find_item_ty_spans(
if let Res::Def(kind, def_id) = path.res if let Res::Def(kind, def_id) = path.res
&& matches!(kind, DefKind::Enum | DefKind::Struct | DefKind::Union) && matches!(kind, DefKind::Enum | DefKind::Struct | DefKind::Union)
{ {
let check_params = def_id.as_local().map_or(true, |def_id| { let check_params = def_id.as_local().is_none_or(|def_id| {
if def_id == needle { if def_id == needle {
spans.push(ty.span); spans.push(ty.span);
} }

View file

@ -266,7 +266,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for LayoutConstrainedPlaceVisitor<'a, 'tcx> {
// place, i.e. the expression is a place expression and not a dereference // place, i.e. the expression is a place expression and not a dereference
// (since dereferencing something leads us to a different place). // (since dereferencing something leads us to a different place).
ExprKind::Deref { .. } => {} ExprKind::Deref { .. } => {}
ref kind if ExprCategory::of(kind).map_or(true, |cat| cat == ExprCategory::Place) => { ref kind if ExprCategory::of(kind).is_none_or(|cat| cat == ExprCategory::Place) => {
visit::walk_expr(self, expr); visit::walk_expr(self, expr);
} }

View file

@ -608,7 +608,7 @@ where
let before = diffs_before.as_mut().map(next_in_dataflow_order); let before = diffs_before.as_mut().map(next_in_dataflow_order);
assert!(diffs_after.is_empty()); assert!(diffs_after.is_empty());
assert!(diffs_before.as_ref().map_or(true, ExactSizeIterator::is_empty)); assert!(diffs_before.as_ref().is_none_or(ExactSizeIterator::is_empty));
let terminator = self.cursor.body()[block].terminator(); let terminator = self.cursor.body()[block].terminator();
let mut terminator_str = String::new(); let mut terminator_str = String::new();

View file

@ -135,7 +135,7 @@ impl CoverageGraph {
bb_to_bcb[bb] = Some(bcb); bb_to_bcb[bb] = Some(bcb);
} }
let is_out_summable = basic_blocks.last().map_or(false, |&bb| { let is_out_summable = basic_blocks.last().is_some_and(|&bb| {
bcb_filtered_successors(mir_body[bb].terminator()).is_out_summable() bcb_filtered_successors(mir_body[bb].terminator()).is_out_summable()
}); });
let bcb_data = BasicCoverageBlockData { basic_blocks, is_out_summable }; let bcb_data = BasicCoverageBlockData { basic_blocks, is_out_summable };

View file

@ -273,7 +273,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
// //
// For this we set `next_orig_uv` to the next smallest, not yet compressed, // For this we set `next_orig_uv` to the next smallest, not yet compressed,
// universe of the input. // universe of the input.
if next_orig_uv.map_or(true, |curr_next_uv| uv.cannot_name(curr_next_uv)) { if next_orig_uv.is_none_or(|curr_next_uv| uv.cannot_name(curr_next_uv)) {
next_orig_uv = Some(uv); next_orig_uv = Some(uv);
} }
} }

View file

@ -2095,7 +2095,7 @@ impl<'a> Parser<'a> {
// point literal here, since there's no use of the exponent // point literal here, since there's no use of the exponent
// syntax that also constitutes a valid integer, so we need // syntax that also constitutes a valid integer, so we need
// not check for that. // not check for that.
if suffix.map_or(true, |s| s == sym::f32 || s == sym::f64) if suffix.is_none_or(|s| s == sym::f32 || s == sym::f64)
&& symbol.as_str().chars().all(|c| c.is_numeric() || c == '_') && symbol.as_str().chars().all(|c| c.is_numeric() || c == '_')
&& self.token.span.hi() == next_token.span.lo() && self.token.span.hi() == next_token.span.lo()
{ {

View file

@ -1231,7 +1231,7 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
continue; continue;
} }
let is_positional = variant.fields.raw.first().map_or(false, |field| { let is_positional = variant.fields.raw.first().is_some_and(|field| {
field.name.as_str().starts_with(|c: char| c.is_ascii_digit()) field.name.as_str().starts_with(|c: char| c.is_ascii_digit())
}); });
let report_on = let report_on =

View file

@ -397,7 +397,7 @@ impl Resolver<'_, '_> {
} }
ImportKind::ExternCrate { id, .. } => { ImportKind::ExternCrate { id, .. } => {
let def_id = self.local_def_id(id); let def_id = self.local_def_id(id);
if self.extern_crate_map.get(&def_id).map_or(true, |&cnum| { if self.extern_crate_map.get(&def_id).is_none_or(|&cnum| {
!tcx.is_compiler_builtins(cnum) !tcx.is_compiler_builtins(cnum)
&& !tcx.is_panic_runtime(cnum) && !tcx.is_panic_runtime(cnum)
&& !tcx.has_global_allocator(cnum) && !tcx.has_global_allocator(cnum)

View file

@ -322,7 +322,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id(); let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy(); let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
let from_item = let from_item =
self.extern_prelude.get(&ident).map_or(true, |entry| entry.introduced_by_item); self.extern_prelude.get(&ident).is_none_or(|entry| entry.introduced_by_item);
// Only suggest removing an import if both bindings are to the same def, if both spans // Only suggest removing an import if both bindings are to the same def, if both spans
// aren't dummy spans. Further, if both bindings are imports, then the ident must have // aren't dummy spans. Further, if both bindings are imports, then the ident must have
// been introduced by an item. // been introduced by an item.
@ -537,7 +537,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
) { ) {
module.for_each_child(self, |_this, ident, _ns, binding| { module.for_each_child(self, |_this, ident, _ns, binding| {
let res = binding.res(); let res = binding.res();
if filter_fn(res) && ctxt.map_or(true, |ctxt| ctxt == ident.span.ctxt()) { if filter_fn(res) && ctxt.is_none_or(|ctxt| ctxt == ident.span.ctxt()) {
names.push(TypoSuggestion::typo_from_ident(ident, res)); names.push(TypoSuggestion::typo_from_ident(ident, res));
} }
}); });
@ -1229,7 +1229,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
_ => res.opt_def_id(), _ => res.opt_def_id(),
}; };
let child_doc_visible = doc_visible let child_doc_visible = doc_visible
&& (did.map_or(true, |did| did.is_local() || !this.tcx.is_doc_hidden(did))); && did.is_none_or(|did| did.is_local() || !this.tcx.is_doc_hidden(did));
// collect results based on the filter function // collect results based on the filter function
// avoid suggesting anything from the same module in which we are resolving // avoid suggesting anything from the same module in which we are resolving

View file

@ -289,7 +289,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
if let ImportKind::Glob { ref max_vis, .. } = import.kind { if let ImportKind::Glob { ref max_vis, .. } = import.kind {
if vis == import_vis if vis == import_vis
|| max_vis.get().map_or(true, |max_vis| vis.is_at_least(max_vis, self.tcx)) || max_vis.get().is_none_or(|max_vis| vis.is_at_least(max_vis, self.tcx))
{ {
max_vis.set(Some(vis.expect_local())) max_vis.set(Some(vis.expect_local()))
} }

View file

@ -612,7 +612,7 @@ impl MaybeExported<'_> {
return vis.kind.is_pub(); return vis.kind.is_pub();
} }
}; };
def_id.map_or(true, |def_id| r.effective_visibilities.is_exported(def_id)) def_id.is_none_or(|def_id| r.effective_visibilities.is_exported(def_id))
} }
} }
@ -5104,7 +5104,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
fn def_id_matches_path(tcx: TyCtxt<'_>, mut def_id: DefId, expected_path: &[&str]) -> bool { fn def_id_matches_path(tcx: TyCtxt<'_>, mut def_id: DefId, expected_path: &[&str]) -> bool {
let mut path = expected_path.iter().rev(); let mut path = expected_path.iter().rev();
while let (Some(parent), Some(next_step)) = (tcx.opt_parent(def_id), path.next()) { while let (Some(parent), Some(next_step)) = (tcx.opt_parent(def_id), path.next()) {
if !tcx.opt_item_name(def_id).map_or(false, |n| n.as_str() == *next_step) { if !tcx.opt_item_name(def_id).is_some_and(|n| n.as_str() == *next_step) {
return false; return false;
} }
def_id = parent; def_id = parent;

View file

@ -1696,7 +1696,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
) => { ) => {
// Don't suggest macro if it's unstable. // Don't suggest macro if it's unstable.
let suggestable = def_id.is_local() let suggestable = def_id.is_local()
|| self.r.tcx.lookup_stability(def_id).map_or(true, |s| s.is_stable()); || self.r.tcx.lookup_stability(def_id).is_none_or(|s| s.is_stable());
err.span_label(span, fallback_label.to_string()); err.span_label(span, fallback_label.to_string());
@ -2135,7 +2135,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
.r .r
.delegation_fn_sigs .delegation_fn_sigs
.get(&self.r.local_def_id(assoc_item.id)) .get(&self.r.local_def_id(assoc_item.id))
.map_or(false, |sig| sig.has_self) => .is_some_and(|sig| sig.has_self) =>
{ {
AssocSuggestion::MethodWithSelf { called } AssocSuggestion::MethodWithSelf { called }
} }
@ -2166,7 +2166,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
.r .r
.delegation_fn_sigs .delegation_fn_sigs
.get(&def_id) .get(&def_id)
.map_or(false, |sig| sig.has_self), .is_some_and(|sig| sig.has_self),
None => self None => self
.r .r
.tcx .tcx

View file

@ -1242,7 +1242,7 @@ impl<'ra> ResolverArenas<'ra> {
no_implicit_prelude, no_implicit_prelude,
)))); ))));
let def_id = module.opt_def_id(); let def_id = module.opt_def_id();
if def_id.map_or(true, |def_id| def_id.is_local()) { if def_id.is_none_or(|def_id| def_id.is_local()) {
self.local_modules.borrow_mut().push(module); self.local_modules.borrow_mut().push(module);
} }
if let Some(def_id) = def_id { if let Some(def_id) = def_id {

View file

@ -1055,7 +1055,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
span: Span, span: Span,
) { ) {
if let Some(Res::NonMacroAttr(kind)) = res { if let Some(Res::NonMacroAttr(kind)) = res {
if kind != NonMacroAttrKind::Tool && binding.map_or(true, |b| b.is_import()) { if kind != NonMacroAttrKind::Tool && binding.is_none_or(|b| b.is_import()) {
let binding_span = binding.map(|binding| binding.span); let binding_span = binding.map(|binding| binding.span);
self.dcx().emit_err(errors::CannotUseThroughAnImport { self.dcx().emit_err(errors::CannotUseThroughAnImport {
span, span,

View file

@ -350,10 +350,7 @@ pub fn strip_generics_from_path(path_str: &str) -> Result<Box<str>, MalformedGen
/// If there are no doc-comments, return true. /// If there are no doc-comments, return true.
/// FIXME(#78591): Support both inner and outer attributes on the same item. /// FIXME(#78591): Support both inner and outer attributes on the same item.
pub fn inner_docs(attrs: &[impl AttributeExt]) -> bool { pub fn inner_docs(attrs: &[impl AttributeExt]) -> bool {
attrs attrs.iter().find(|a| a.doc_str().is_some()).is_none_or(|a| a.style() == ast::AttrStyle::Inner)
.iter()
.find(|a| a.doc_str().is_some())
.map_or(true, |a| a.style() == ast::AttrStyle::Inner)
} }
/// Has `#[rustc_doc_primitive]` or `#[doc(keyword)]`. /// Has `#[rustc_doc_primitive]` or `#[doc(keyword)]`.

View file

@ -675,7 +675,7 @@ impl OutputTypes {
/// Returns `true` if user specified a name and not just produced type /// Returns `true` if user specified a name and not just produced type
pub fn contains_explicit_name(&self, key: &OutputType) -> bool { pub fn contains_explicit_name(&self, key: &OutputType) -> bool {
self.0.get(key).map_or(false, |f| f.is_some()) self.0.get(key).is_some_and(|f| f.is_some())
} }
pub fn iter(&self) -> BTreeMapIter<'_, OutputType, Option<OutFileName>> { pub fn iter(&self) -> BTreeMapIter<'_, OutputType, Option<OutFileName>> {

View file

@ -420,8 +420,7 @@ fn make_elided_region_spans_suggs<'a>(
let mut process_consecutive_brackets = let mut process_consecutive_brackets =
|span: Option<Span>, spans_suggs: &mut Vec<(Span, String)>| { |span: Option<Span>, spans_suggs: &mut Vec<(Span, String)>| {
if span if span.is_some_and(|span| bracket_span.is_none_or(|bracket_span| span == bracket_span))
.is_some_and(|span| bracket_span.map_or(true, |bracket_span| span == bracket_span))
{ {
consecutive_brackets += 1; consecutive_brackets += 1;
} else if let Some(bracket_span) = bracket_span.take() { } else if let Some(bracket_span) = bracket_span.take() {