bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Run clippy --fix for unnecessary_map_or lint

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_ast_lowering/src/delegation.rs
View file

@ -72,7 +72,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
if let Some(local_sig_id) = def_id.as_local() {
// The value may be missing due to recursive delegation.
// 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 {
match self.tcx.def_kind(def_id) {
DefKind::Fn => false,

2
compiler/rustc_ast_passes/src/feature_gate.rs
View file

@ -83,7 +83,7 @@ impl<'a> PostExpansionVisitor<'a> {
feature_err_issue(&self.sess, feature, span, GateIssue::Language, explain).emit();
}
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(
span,
format!(

2
compiler/rustc_attr_parsing/src/attributes/repr.rs
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
// (e.g. if we only pretty-print the source), so we have to gate
// 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");
}
}

2
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View file

@ -2480,7 +2480,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
// To support cases like `|| { v.call(|this| v.get()) }`
// FIXME: actually support such cases (need to figure out how to move from the
// 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));
}

4
compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
View file

@ -131,10 +131,10 @@ impl<'tcx> BorrowExplanation<'tcx> {
&& let Ok(pat) = tcx.sess.source_map().span_to_snippet(pat.span)
{
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
// 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(
var_or_use_span,
format!("{borrow_desc}borrow later {message}"),

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
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).
ty::Adt(def, args)
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)
}

2
compiler/rustc_errors/src/emitter.rs
View file

@ -3146,7 +3146,7 @@ impl FileWithAnnotatedLines {
add_annotation_to_file(&mut output, Lrc::clone(&file), line, ann.as_line());
}
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 {
add_annotation_to_file(&mut output, Lrc::clone(&file), line_end, ann.as_line());
}

2
compiler/rustc_errors/src/json.rs
View file

@ -463,7 +463,7 @@ impl DiagnosticSpan {
// is an empty string, increase the length to include the newline so we don't
// leave an empty line
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)
&& after.starts_with('\n')
{

2
compiler/rustc_errors/src/lib.rs
View file

@ -1717,7 +1717,7 @@ impl DiagCtxtInner {
let bugs: Vec<_> =
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 mut out = self
.ice_file

2
compiler/rustc_expand/src/config.rs
View file

@ -391,7 +391,7 @@ impl<'a> StripUnconfigured<'a> {
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)
}),
Some(meta_item),

2
compiler/rustc_expand/src/mbe/diagnostics.rs
View file

@ -159,7 +159,7 @@ impl<'dcx, 'matcher> Tracker<'matcher> for CollectTrackerAndEmitter<'dcx, 'match
if self
.best_failure
.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 {
token: token.clone(),

2
compiler/rustc_hir/src/def.rs
View file

@ -794,7 +794,7 @@ impl<Id> Res<Id> {
/// Always returns `true` if `self` is `Res::Err`
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

2
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View file

@ -1210,7 +1210,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// - foo((), "current", 42u32, "next")
// + 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()
})
}

9
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View file

@ -1143,7 +1143,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.may_coerce(found, ty)
}
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();
self.may_coerce(found, ret_ty)
})
@ -1784,14 +1784,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let results = self.typeck_results.borrow();
// First, look for a `Clone::clone` call
if segment.ident.name == sym::clone
&& results.type_dependent_def_id(expr.hir_id).map_or(
false,
|did| {
&& results.type_dependent_def_id(expr.hir_id).is_some_and(|did| {
let assoc_item = self.tcx.associated_item(did);
assoc_item.container == ty::AssocItemContainer::Trait
&& 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
// 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(..)))

25
compiler/rustc_hir_typeck/src/method/suggest.rs
View file

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

2
compiler/rustc_index/src/interval.rs
View file

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

2
compiler/rustc_lint/src/expect.rs
View file

@ -57,7 +57,7 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
let expect_id = canonicalize_id(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 note = expectation.is_unfulfilled_lint_expectations;

2
compiler/rustc_metadata/src/creader.rs
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
// private in metadata, so we ignore that field.
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;
}

4
compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
View file

@ -97,7 +97,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
debug_assert!(prov.len() <= 1);
if let Some(entry) = prov.first() {
// 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)
} else {
// 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.
let entry_start = cmp::max(entry.0, src.start);
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.
bytes.push((offset, entry.1));
} else {

2
compiler/rustc_middle/src/ty/closure.rs
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.
// The child may have more, if it is capturing sub-fields out of
// 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)
}) {
let (child_field_idx, child_capture) = child_captures.next().unwrap();

2
compiler/rustc_middle/src/ty/instance.rs
View file

@ -328,7 +328,7 @@ impl<'tcx> InstanceKind<'tcx> {
// We include enums without destructors to allow, say, optimizing
// drops of `Option::None` before LTO. We also respect the intent of
// `#[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 {
ty::InstanceKind::DropGlue(..) => adt_def.destructor(tcx).map(|dtor| dtor.did),
ty::InstanceKind::AsyncDropGlueCtorShim(..) => {

4
compiler/rustc_middle/src/ty/sty.rs
View file

@ -1894,11 +1894,11 @@ impl<'tcx> Ty<'tcx> {
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
.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,

2
compiler/rustc_middle/src/values.rs
View file

@ -360,7 +360,7 @@ fn find_item_ty_spans(
if let Res::Def(kind, def_id) = path.res
&& 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 {
spans.push(ty.span);
}

2
compiler/rustc_mir_build/src/check_unsafety.rs
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
// (since dereferencing something leads us to a different place).
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);
}

2
compiler/rustc_mir_dataflow/src/framework/graphviz.rs
View file

@ -608,7 +608,7 @@ where
let before = diffs_before.as_mut().map(next_in_dataflow_order);
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 mut terminator_str = String::new();

2
compiler/rustc_mir_transform/src/coverage/graph.rs
View file

@ -135,7 +135,7 @@ impl CoverageGraph {
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()
});
let bcb_data = BasicCoverageBlockData { basic_blocks, is_out_summable };

2
compiler/rustc_next_trait_solver/src/canonicalizer.rs
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,
// 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);
}
}

2
compiler/rustc_parse/src/parser/expr.rs
View file

@ -2095,7 +2095,7 @@ impl<'a> Parser<'a> {
// point literal here, since there's no use of the exponent
// syntax that also constitutes a valid integer, so we need
// 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 == '_')
&& self.token.span.hi() == next_token.span.lo()
{

2
compiler/rustc_passes/src/dead.rs
View file

@ -1231,7 +1231,7 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
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())
});
let report_on =

2
compiler/rustc_resolve/src/check_unused.rs
View file

@ -397,7 +397,7 @@ impl Resolver<'_, '_> {
}
ImportKind::ExternCrate { 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_panic_runtime(cnum)
&& !tcx.has_global_allocator(cnum)

6
compiler/rustc_resolve/src/diagnostics.rs
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 has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
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
// aren't dummy spans. Further, if both bindings are imports, then the ident must have
// been introduced by an item.
@ -537,7 +537,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
) {
module.for_each_child(self, |_this, ident, _ns, binding| {
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));
}
});
@ -1229,7 +1229,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
_ => res.opt_def_id(),
};
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
// avoid suggesting anything from the same module in which we are resolving

2
compiler/rustc_resolve/src/imports.rs
View file

@ -289,7 +289,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
if let ImportKind::Glob { ref max_vis, .. } = import.kind {
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()))
}

4
compiler/rustc_resolve/src/late.rs
View file

@ -612,7 +612,7 @@ impl MaybeExported<'_> {
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 {
let mut path = expected_path.iter().rev();
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;
}
def_id = parent;

6
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -1696,7 +1696,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
) => {
// Don't suggest macro if it's unstable.
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());
@ -2135,7 +2135,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
.r
.delegation_fn_sigs
.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 }
}
@ -2166,7 +2166,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
.r
.delegation_fn_sigs
.get(&def_id)
.map_or(false, |sig| sig.has_self),
.is_some_and(|sig| sig.has_self),
None => self
.r
.tcx

2
compiler/rustc_resolve/src/lib.rs
View file

@ -1242,7 +1242,7 @@ impl<'ra> ResolverArenas<'ra> {
no_implicit_prelude,
))));
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);
}
if let Some(def_id) = def_id {

2
compiler/rustc_resolve/src/macros.rs
View file

@ -1055,7 +1055,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
span: Span,
) {
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);
self.dcx().emit_err(errors::CannotUseThroughAnImport {
span,

5
compiler/rustc_resolve/src/rustdoc.rs
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.
/// FIXME(#78591): Support both inner and outer attributes on the same item.
pub fn inner_docs(attrs: &[impl AttributeExt]) -> bool {
attrs
.iter()
.find(|a| a.doc_str().is_some())
.map_or(true, |a| a.style() == ast::AttrStyle::Inner)
attrs.iter().find(|a| a.doc_str().is_some()).is_none_or(|a| a.style() == ast::AttrStyle::Inner)
}
/// Has `#[rustc_doc_primitive]` or `#[doc(keyword)]`.

2
compiler/rustc_session/src/config.rs
View file

@ -675,7 +675,7 @@ impl OutputTypes {
/// Returns `true` if user specified a name and not just produced type
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>> {

3
compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/static_impl_trait.rs
View file

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