From 8683439a20b7bbb96a23751b9010b139809cb236 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Thu, 29 Aug 2024 12:14:34 +0200 Subject: [PATCH] Fix clippy lints --- src/librustdoc/clean/auto_trait.rs | 2 +- src/librustdoc/clean/blanket_impl.rs | 2 +- src/librustdoc/clean/inline.rs | 28 ++++++-------- src/librustdoc/clean/mod.rs | 55 +++++++++++++--------------- src/librustdoc/clean/simplify.rs | 2 +- src/librustdoc/clean/types.rs | 31 +++++++--------- src/librustdoc/clean/utils.rs | 12 +++--- src/librustdoc/config.rs | 6 +-- src/librustdoc/core.rs | 2 +- src/librustdoc/doctest.rs | 16 ++++---- src/librustdoc/doctest/make.rs | 2 +- src/librustdoc/doctest/markdown.rs | 2 +- src/librustdoc/doctest/runner.rs | 6 ++- src/librustdoc/error.rs | 2 +- src/librustdoc/formats/cache.rs | 12 +++--- src/librustdoc/html/format.rs | 19 +++++----- 16 files changed, 94 insertions(+), 105 deletions(-) diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index f46ffea830e68..577b10a31ae4c 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -341,7 +341,7 @@ fn clean_region_outlives_constraints<'tcx>( .map(|®ion| { let lifetime = early_bound_region_name(region) .inspect(|name| assert!(region_params.contains(name))) - .map(|name| Lifetime(name)) + .map(Lifetime) .unwrap_or(Lifetime::statik()); clean::GenericBound::Outlives(lifetime) }) diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs index 48c3fb65203cc..96e7f5c61c3e3 100644 --- a/src/librustdoc/clean/blanket_impl.rs +++ b/src/librustdoc/clean/blanket_impl.rs @@ -24,7 +24,7 @@ pub(crate) fn synthesize_blanket_impls( let mut blanket_impls = Vec::new(); for trait_def_id in tcx.all_traits() { if !cx.cache.effective_visibilities.is_reachable(tcx, trait_def_id) - || cx.generated_synthetics.get(&(ty.skip_binder(), trait_def_id)).is_some() + || cx.generated_synthetics.contains(&(ty.skip_binder(), trait_def_id)) { continue; } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index f8953f0ebcfb5..962a5a05737f4 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -54,7 +54,7 @@ pub(crate) fn try_inline( debug!("attrs={attrs:?}"); let attrs_without_docs = attrs.map(|(attrs, def_id)| { - (attrs.into_iter().filter(|a| a.doc_str().is_none()).cloned().collect::>(), def_id) + (attrs.iter().filter(|a| a.doc_str().is_none()).cloned().collect::>(), def_id) }); let attrs_without_docs = attrs_without_docs.as_ref().map(|(attrs, def_id)| (&attrs[..], *def_id)); @@ -288,10 +288,7 @@ pub(crate) fn build_external_trait(cx: &mut DocContext<'_>, did: DefId) -> clean clean::Trait { def_id: did, generics, items: trait_items, bounds: supertrait_bounds } } -pub(crate) fn build_function<'tcx>( - cx: &mut DocContext<'tcx>, - def_id: DefId, -) -> Box { +pub(crate) fn build_function(cx: &mut DocContext<'_>, def_id: DefId) -> Box { let sig = cx.tcx.fn_sig(def_id).instantiate_identity(); // The generics need to be cleaned before the signature. let mut generics = @@ -425,7 +422,7 @@ pub(crate) fn merge_attrs( both.cfg(cx.tcx, &cx.cache.hidden_cfg), ) } else { - (Attributes::from_ast(&old_attrs), old_attrs.cfg(cx.tcx, &cx.cache.hidden_cfg)) + (Attributes::from_ast(old_attrs), old_attrs.cfg(cx.tcx, &cx.cache.hidden_cfg)) } } @@ -791,16 +788,15 @@ fn build_macro( /// implementation for `AssociatedType` fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean::Generics { for pred in &mut g.where_predicates { - match *pred { - clean::WherePredicate::BoundPredicate { ty: clean::SelfTy, ref mut bounds, .. } => { - bounds.retain(|bound| match bound { - clean::GenericBound::TraitBound(clean::PolyTrait { trait_, .. }, _) => { - trait_.def_id() != trait_did - } - _ => true, - }); - } - _ => {} + if let clean::WherePredicate::BoundPredicate { ty: clean::SelfTy, ref mut bounds, .. } = + *pred + { + bounds.retain(|bound| match bound { + clean::GenericBound::TraitBound(clean::PolyTrait { trait_, .. }, _) => { + trait_.def_id() != trait_did + } + _ => true, + }); } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 5260e363dd68c..3cb02f379e4f7 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -266,7 +266,7 @@ fn clean_poly_trait_ref_with_constraints<'tcx>( ) } -fn clean_lifetime<'tcx>(lifetime: &hir::Lifetime, cx: &mut DocContext<'tcx>) -> Lifetime { +fn clean_lifetime(lifetime: &hir::Lifetime, cx: &mut DocContext<'_>) -> Lifetime { if let Some( rbv::ResolvedArg::EarlyBound(did) | rbv::ResolvedArg::LateBound(_, _, did) @@ -274,7 +274,7 @@ fn clean_lifetime<'tcx>(lifetime: &hir::Lifetime, cx: &mut DocContext<'tcx>) -> ) = cx.tcx.named_bound_var(lifetime.hir_id) && let Some(lt) = cx.args.get(&did.to_def_id()).and_then(|arg| arg.as_lt()) { - return lt.clone(); + return *lt; } Lifetime(lifetime.ident.name) } @@ -285,7 +285,7 @@ pub(crate) fn clean_const<'tcx>( ) -> ConstantKind { match &constant.kind { hir::ConstArgKind::Path(qpath) => { - ConstantKind::Path { path: qpath_to_string(&qpath).into() } + ConstantKind::Path { path: qpath_to_string(qpath).into() } } hir::ConstArgKind::Anon(anon) => ConstantKind::Anonymous { body: anon.body }, } @@ -299,7 +299,7 @@ pub(crate) fn clean_middle_const<'tcx>( ConstantKind::TyConst { expr: constant.skip_binder().to_string().into() } } -pub(crate) fn clean_middle_region<'tcx>(region: ty::Region<'tcx>) -> Option { +pub(crate) fn clean_middle_region(region: ty::Region<'_>) -> Option { match *region { ty::ReStatic => Some(Lifetime::statik()), _ if !region.has_name() => None, @@ -389,8 +389,8 @@ fn clean_poly_trait_predicate<'tcx>( }) } -fn clean_region_outlives_predicate<'tcx>( - pred: ty::RegionOutlivesPredicate<'tcx>, +fn clean_region_outlives_predicate( + pred: ty::RegionOutlivesPredicate<'_>, ) -> Option { let ty::OutlivesPredicate(a, b) = pred; @@ -513,10 +513,10 @@ fn projection_to_path_segment<'tcx>( } } -fn clean_generic_param_def<'tcx>( +fn clean_generic_param_def( def: &ty::GenericParamDef, defaults: ParamDefaults, - cx: &mut DocContext<'tcx>, + cx: &mut DocContext<'_>, ) -> GenericParamDef { let (name, kind) = match def.kind { ty::GenericParamDefKind::Lifetime => { @@ -1303,10 +1303,7 @@ pub(crate) fn clean_impl_item<'tcx>( }) } -pub(crate) fn clean_middle_assoc_item<'tcx>( - assoc_item: &ty::AssocItem, - cx: &mut DocContext<'tcx>, -) -> Item { +pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocContext<'_>) -> Item { let tcx = cx.tcx; let kind = match assoc_item.kind { ty::AssocKind::Const => { @@ -1459,7 +1456,7 @@ pub(crate) fn clean_middle_assoc_item<'tcx>( // which only has one associated type, which is not a GAT, so whatever. } } - bounds.extend(mem::replace(pred_bounds, Vec::new())); + bounds.extend(mem::take(pred_bounds)); false } _ => true, @@ -1661,7 +1658,7 @@ fn clean_qpath<'tcx>(hir_ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> Type expanded } else { // First we check if it's a private re-export. - let path = if let Some(path) = first_non_private(cx, hir_id, &path) { + let path = if let Some(path) = first_non_private(cx, hir_id, path) { path } else { clean_path(path, cx) @@ -1796,7 +1793,7 @@ fn maybe_expand_private_type_alias<'tcx>( } Some(cx.enter_alias(args, def_id.to_def_id(), |cx| { - cx.with_param_env(def_id.to_def_id(), |cx| clean_ty(&ty, cx)) + cx.with_param_env(def_id.to_def_id(), |cx| clean_ty(ty, cx)) })) } @@ -1806,8 +1803,8 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T match ty.kind { TyKind::Never => Primitive(PrimitiveType::Never), TyKind::Ptr(ref m) => RawPointer(m.mutbl, Box::new(clean_ty(m.ty, cx))), - TyKind::Ref(ref l, ref m) => { - let lifetime = if l.is_anonymous() { None } else { Some(clean_lifetime(*l, cx)) }; + TyKind::Ref(l, ref m) => { + let lifetime = if l.is_anonymous() { None } else { Some(clean_lifetime(l, cx)) }; BorrowedRef { lifetime, mutability: m.mutbl, type_: Box::new(clean_ty(m.ty, cx)) } } TyKind::Slice(ty) => Slice(Box::new(clean_ty(ty, cx))), @@ -1843,17 +1840,17 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T TyKind::Tup(tys) => Tuple(tys.iter().map(|ty| clean_ty(ty, cx)).collect()), TyKind::OpaqueDef(item_id, _, _) => { let item = cx.tcx.hir().item(item_id); - if let hir::ItemKind::OpaqueTy(ref ty) = item.kind { + if let hir::ItemKind::OpaqueTy(ty) = item.kind { ImplTrait(ty.bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect()) } else { unreachable!() } } TyKind::Path(_) => clean_qpath(ty, cx), - TyKind::TraitObject(bounds, ref lifetime, _) => { + TyKind::TraitObject(bounds, lifetime, _) => { let bounds = bounds.iter().map(|(bound, _)| clean_poly_trait_ref(bound, cx)).collect(); let lifetime = - if !lifetime.is_elided() { Some(clean_lifetime(*lifetime, cx)) } else { None }; + if !lifetime.is_elided() { Some(clean_lifetime(lifetime, cx)) } else { None }; DynTrait(bounds, lifetime) } TyKind::BareFn(barefn) => BareFunction(Box::new(clean_bare_fn_ty(barefn, cx))), @@ -2355,7 +2352,7 @@ pub(crate) fn clean_field<'tcx>(field: &hir::FieldDef<'tcx>, cx: &mut DocContext clean_field_with_def_id(field.def_id.to_def_id(), field.ident.name, clean_ty(field.ty, cx), cx) } -pub(crate) fn clean_middle_field<'tcx>(field: &ty::FieldDef, cx: &mut DocContext<'tcx>) -> Item { +pub(crate) fn clean_middle_field(field: &ty::FieldDef, cx: &mut DocContext<'_>) -> Item { clean_field_with_def_id( field.did, field.name, @@ -2378,7 +2375,7 @@ pub(crate) fn clean_field_with_def_id( Item::from_def_id_and_parts(def_id, Some(name), StructFieldItem(ty), cx) } -pub(crate) fn clean_variant_def<'tcx>(variant: &ty::VariantDef, cx: &mut DocContext<'tcx>) -> Item { +pub(crate) fn clean_variant_def(variant: &ty::VariantDef, cx: &mut DocContext<'_>) -> Item { let discriminant = match variant.discr { ty::VariantDiscr::Explicit(def_id) => Some(Discriminant { expr: None, value: def_id }), ty::VariantDiscr::Relative(_) => None, @@ -2526,7 +2523,7 @@ fn clean_generic_args<'tcx>( .filter_map(|arg| { Some(match arg { hir::GenericArg::Lifetime(lt) if !lt.is_anonymous() => { - GenericArg::Lifetime(clean_lifetime(*lt, cx)) + GenericArg::Lifetime(clean_lifetime(lt, cx)) } hir::GenericArg::Lifetime(_) => GenericArg::Lifetime(Lifetime::elided()), hir::GenericArg::Type(ty) => GenericArg::Type(clean_ty(ty, cx)), @@ -2579,11 +2576,11 @@ fn clean_bare_fn_ty<'tcx>( BareFunctionDecl { safety: bare_fn.safety, abi: bare_fn.abi, decl, generic_params } } -pub(crate) fn reexport_chain<'tcx>( - tcx: TyCtxt<'tcx>, +pub(crate) fn reexport_chain( + tcx: TyCtxt<'_>, import_def_id: LocalDefId, target_def_id: DefId, -) -> &'tcx [Reexport] { +) -> &[Reexport] { for child in tcx.module_children_local(tcx.local_parent(import_def_id)) { if child.res.opt_def_id() == Some(target_def_id) && child.reexport_chain.first().and_then(|r| r.id()) == Some(import_def_id.to_def_id()) @@ -2803,7 +2800,7 @@ fn clean_maybe_renamed_item<'tcx>( fields: variant_data.fields().iter().map(|x| clean_field(x, cx)).collect(), }), ItemKind::Impl(impl_) => return clean_impl(impl_, item.owner_id.def_id, cx), - ItemKind::Macro(ref macro_def, MacroKind::Bang) => { + ItemKind::Macro(macro_def, MacroKind::Bang) => { let ty_vis = cx.tcx.visibility(def_id); MacroItem(Macro { // FIXME this shouldn't be false @@ -3134,9 +3131,7 @@ fn clean_assoc_item_constraint<'tcx>( } } -fn clean_bound_vars<'tcx>( - bound_vars: &'tcx ty::List, -) -> Vec { +fn clean_bound_vars(bound_vars: &ty::List) -> Vec { bound_vars .into_iter() .filter_map(|var| match var { diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs index 1d81ae3eb8ba7..b59f939025e1a 100644 --- a/src/librustdoc/clean/simplify.rs +++ b/src/librustdoc/clean/simplify.rs @@ -70,7 +70,7 @@ pub(crate) fn where_clauses(cx: &DocContext<'_>, clauses: ThinVec) -> ThinVe pub(crate) fn merge_bounds( cx: &clean::DocContext<'_>, - bounds: &mut Vec, + bounds: &mut [clean::GenericBound], trait_did: DefId, assoc: clean::PathSegment, rhs: &clean::Term, diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index 63d71a73cdfc8..51da252da24e4 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -368,11 +368,11 @@ fn is_field_vis_inherited(tcx: TyCtxt<'_>, def_id: DefId) -> bool { } impl Item { - pub(crate) fn stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option { + pub(crate) fn stability(&self, tcx: TyCtxt<'_>) -> Option { self.def_id().and_then(|did| tcx.lookup_stability(did)) } - pub(crate) fn const_stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option { + pub(crate) fn const_stability(&self, tcx: TyCtxt<'_>) -> Option { self.def_id().and_then(|did| tcx.lookup_const_stability(did)) } @@ -945,9 +945,9 @@ pub(crate) trait AttributesExt { where Self: 'a; - fn lists<'a>(&'a self, name: Symbol) -> Self::AttributeIterator<'a>; + fn lists(&self, name: Symbol) -> Self::AttributeIterator<'_>; - fn iter<'a>(&'a self) -> Self::Attributes<'a>; + fn iter(&self) -> Self::Attributes<'_>; fn cfg(&self, tcx: TyCtxt<'_>, hidden_cfg: &FxHashSet) -> Option> { let sess = tcx.sess; @@ -1043,15 +1043,15 @@ impl AttributesExt for [ast::Attribute] { type AttributeIterator<'a> = impl Iterator + 'a; type Attributes<'a> = impl Iterator + 'a; - fn lists<'a>(&'a self, name: Symbol) -> Self::AttributeIterator<'a> { + fn lists(&self, name: Symbol) -> Self::AttributeIterator<'_> { self.iter() .filter(move |attr| attr.has_name(name)) .filter_map(ast::Attribute::meta_item_list) .flatten() } - fn iter<'a>(&'a self) -> Self::Attributes<'a> { - self.into_iter() + fn iter(&self) -> Self::Attributes<'_> { + self.iter() } } @@ -1061,15 +1061,15 @@ impl AttributesExt for [(Cow<'_, ast::Attribute>, Option)] { type Attributes<'a> = impl Iterator + 'a where Self: 'a; - fn lists<'a>(&'a self, name: Symbol) -> Self::AttributeIterator<'a> { + fn lists(&self, name: Symbol) -> Self::AttributeIterator<'_> { AttributesExt::iter(self) .filter(move |attr| attr.has_name(name)) .filter_map(ast::Attribute::meta_item_list) .flatten() } - fn iter<'a>(&'a self) -> Self::Attributes<'a> { - self.into_iter().map(move |(attr, _)| match attr { + fn iter(&self) -> Self::Attributes<'_> { + self.iter().map(move |(attr, _)| match attr { Cow::Borrowed(attr) => *attr, Cow::Owned(attr) => attr, }) @@ -1389,7 +1389,7 @@ pub(crate) struct FnDecl { impl FnDecl { pub(crate) fn receiver_type(&self) -> Option<&Type> { - self.inputs.values.get(0).and_then(|v| v.to_receiver()) + self.inputs.values.first().and_then(|v| v.to_receiver()) } } @@ -1502,7 +1502,7 @@ impl Type { pub(crate) fn without_borrowed_ref(&self) -> &Type { let mut result = self; while let Type::BorrowedRef { type_, .. } = result { - result = &*type_; + result = type_; } result } @@ -1631,10 +1631,7 @@ impl Type { } pub(crate) fn is_self_type(&self) -> bool { - match *self { - SelfTy => true, - _ => false, - } + matches!(*self, Type::SelfTy) } pub(crate) fn generic_args(&self) -> Option<&GenericArgs> { @@ -1673,7 +1670,7 @@ impl Type { pub(crate) fn def_id(&self, cache: &Cache) -> Option { let t: PrimitiveType = match *self { Type::Path { ref path } => return Some(path.def_id()), - DynTrait(ref bounds, _) => return bounds.get(0).map(|b| b.trait_.def_id()), + DynTrait(ref bounds, _) => return bounds.first().map(|b| b.trait_.def_id()), Primitive(p) => return cache.primitive_locations.get(&p).cloned(), BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference, BorrowedRef { ref type_, .. } => return type_.def_id(cache), diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 68266f3506a01..d826171aa61ce 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -321,9 +321,9 @@ pub(crate) fn name_from_pat(p: &hir::Pat<'_>) -> Symbol { "({})", elts.iter().map(|p| name_from_pat(p).to_string()).collect::>().join(", ") ), - PatKind::Box(p) => return name_from_pat(&*p), - PatKind::Deref(p) => format!("deref!({})", name_from_pat(&*p)), - PatKind::Ref(p, _) => return name_from_pat(&*p), + PatKind::Box(p) => return name_from_pat(p), + PatKind::Deref(p) => format!("deref!({})", name_from_pat(p)), + PatKind::Ref(p, _) => return name_from_pat(p), PatKind::Lit(..) => { warn!( "tried to get argument name from PatKind::Lit, which is silly in function arguments" @@ -333,7 +333,7 @@ pub(crate) fn name_from_pat(p: &hir::Pat<'_>) -> Symbol { PatKind::Range(..) => return kw::Underscore, PatKind::Slice(begin, ref mid, end) => { let begin = begin.iter().map(|p| name_from_pat(p).to_string()); - let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter(); + let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(p))).into_iter(); let end = end.iter().map(|p| name_from_pat(p).to_string()); format!("[{}]", begin.chain(mid).chain(end).collect::>().join(", ")) } @@ -344,7 +344,7 @@ pub(crate) fn print_const(cx: &DocContext<'_>, n: ty::Const<'_>) -> String { match n.kind() { ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, args: _ }) => { let s = if let Some(def) = def.as_local() { - rendered_const(cx.tcx, &cx.tcx.hir().body_owned_by(def), def) + rendered_const(cx.tcx, cx.tcx.hir().body_owned_by(def), def) } else { inline::print_inlined_const(cx.tcx, def) }; @@ -383,7 +383,7 @@ pub(crate) fn print_evaluated_const( fn format_integer_with_underscore_sep(num: &str) -> String { let num_chars: Vec<_> = num.chars().collect(); - let mut num_start_index = if num_chars.get(0) == Some(&'-') { 1 } else { 0 }; + let mut num_start_index = if num_chars.first() == Some(&'-') { 1 } else { 0 }; let chunk_size = match num[num_start_index..].as_bytes() { [b'0', b'b' | b'x', ..] => { num_start_index += 2; diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 9e9d8f02a2ece..9e7b69ec45faa 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -360,7 +360,7 @@ impl Options { return None; } - if rustc_driver::describe_flag_categories(early_dcx, &matches) { + if rustc_driver::describe_flag_categories(early_dcx, matches) { return None; } @@ -374,7 +374,7 @@ impl Options { let codegen_options = CodegenOptions::build(early_dcx, matches); let unstable_opts = UnstableOptions::build(early_dcx, matches); - let remap_path_prefix = match parse_remap_path_prefix(&matches) { + let remap_path_prefix = match parse_remap_path_prefix(matches) { Ok(prefix_mappings) => prefix_mappings, Err(err) => { early_dcx.early_fatal(err); @@ -486,7 +486,7 @@ impl Options { _ => dcx.fatal("too many file operands"), } }; - let input = make_input(early_dcx, &input); + let input = make_input(early_dcx, input); let externs = parse_externs(early_dcx, matches, &unstable_opts); let extern_html_root_urls = match parse_extern_html_roots(matches) { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 08a4a3f3fb264..760514f40fda3 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -288,7 +288,7 @@ pub(crate) fn create_config( let hir = tcx.hir(); let body = hir.body_owned_by(def_id); debug!("visiting body for {def_id:?}"); - EmitIgnoredResolutionErrors::new(tcx).visit_body(&body); + EmitIgnoredResolutionErrors::new(tcx).visit_body(body); (rustc_interface::DEFAULT_QUERY_PROVIDERS.typeck)(tcx, def_id) }; }), diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index 743c1ed507eeb..1ae66fddda621 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -272,7 +272,7 @@ pub(crate) fn run_tests( let mut tests_runner = runner::DocTestRunner::new(); let rustdoc_test_options = IndividualTestOptions::new( - &rustdoc_options, + rustdoc_options, &Some(format!("merged_doctest_{edition}")), PathBuf::from(format!("doctest_{edition}.rs")), ); @@ -307,7 +307,7 @@ pub(crate) fn run_tests( doctest, scraped_test, opts.clone(), - Arc::clone(&rustdoc_options), + Arc::clone(rustdoc_options), unused_extern_reports.clone(), )); } @@ -316,7 +316,7 @@ pub(crate) fn run_tests( // We need to call `test_main` even if there is no doctest to run to get the output // `running 0 tests...`. if ran_edition_tests == 0 || !standalone_tests.is_empty() { - standalone_tests.sort_by(|a, b| a.desc.name.as_slice().cmp(&b.desc.name.as_slice())); + standalone_tests.sort_by(|a, b| a.desc.name.as_slice().cmp(b.desc.name.as_slice())); test::test_main(&test_args, standalone_tests, None); } if nb_errors != 0 { @@ -421,7 +421,7 @@ fn add_exe_suffix(input: String, target: &TargetTriple) -> String { } fn wrapped_rustc_command(rustc_wrappers: &[PathBuf], rustc_binary: &Path) -> Command { - let mut args = rustc_wrappers.iter().map(PathBuf::as_path).chain([rustc_binary].into_iter()); + let mut args = rustc_wrappers.iter().map(PathBuf::as_path).chain([rustc_binary]); let exe = args.next().expect("unable to create rustc command"); let mut command = Command::new(exe); @@ -452,7 +452,7 @@ pub(crate) struct RunnableDocTest { impl RunnableDocTest { fn path_for_merged_doctest(&self) -> PathBuf { - self.test_opts.outdir.path().join(&format!("doctest_{}.rs", self.edition)) + self.test_opts.outdir.path().join(format!("doctest_{}.rs", self.edition)) } } @@ -477,13 +477,13 @@ fn run_test( .unwrap_or_else(|| rustc_interface::util::rustc_path().expect("found rustc")); let mut compiler = wrapped_rustc_command(&rustdoc_options.test_builder_wrappers, rustc_binary); - compiler.arg(&format!("@{}", doctest.global_opts.args_file.display())); + compiler.arg(format!("@{}", doctest.global_opts.args_file.display())); if let Some(sysroot) = &rustdoc_options.maybe_sysroot { compiler.arg(format!("--sysroot={}", sysroot.display())); } - compiler.arg("--edition").arg(&doctest.edition.to_string()); + compiler.arg("--edition").arg(doctest.edition.to_string()); if !doctest.is_multiple_tests { // Setting these environment variables is unneeded if this is a merged doctest. compiler.env("UNSTABLE_RUSTDOC_TEST_PATH", &doctest.test_opts.path); @@ -692,7 +692,7 @@ impl IndividualTestOptions { fn new(options: &RustdocOptions, test_id: &Option, test_path: PathBuf) -> Self { let outdir = if let Some(ref path) = options.persist_doctests { let mut path = path.clone(); - path.push(&test_id.as_deref().unwrap_or_else(|| "")); + path.push(&test_id.as_deref().unwrap_or("")); if let Err(err) = std::fs::create_dir_all(&path) { eprintln!("Couldn't create directory for doctest executables: {err}"); diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs index aed079e5887b0..9de312a413a42 100644 --- a/src/librustdoc/doctest/make.rs +++ b/src/librustdoc/doctest/make.rs @@ -311,7 +311,7 @@ fn parse_source( } ast::ItemKind::ExternCrate(original) => { if !info.found_extern_crate - && let Some(ref crate_name) = crate_name + && let Some(crate_name) = crate_name { info.found_extern_crate = match original { Some(name) => name.as_str() == *crate_name, diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs index 4806d86558997..9a237f8684d8f 100644 --- a/src/librustdoc/doctest/markdown.rs +++ b/src/librustdoc/doctest/markdown.rs @@ -73,7 +73,7 @@ pub(crate) fn test(options: Options) -> Result<(), String> { use rustc_session::config::Input; let input_str = match &options.input { Input::File(path) => { - read_to_string(&path).map_err(|err| format!("{}: {err}", path.display()))? + read_to_string(path).map_err(|err| format!("{}: {err}", path.display()))? } Input::Str { name: _, input } => input.clone(), }; diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs index d49fa3ac5ac5a..9cb220ef7ba4d 100644 --- a/src/librustdoc/doctest/runner.rs +++ b/src/librustdoc/doctest/runner.rs @@ -98,8 +98,10 @@ impl DocTestRunner { code.push_str("extern crate test;\n"); - let test_args = - test_args.iter().map(|arg| format!("{arg:?}.to_string(),")).collect::(); + let test_args = test_args.iter().fold(String::new(), |mut x, arg| { + write!(x, "{arg:?}.to_string(),").unwrap(); + x + }); write!( code, "\ diff --git a/src/librustdoc/error.rs b/src/librustdoc/error.rs index 6ed7eab1abae6..7876125f7fdf7 100644 --- a/src/librustdoc/error.rs +++ b/src/librustdoc/error.rs @@ -39,7 +39,7 @@ macro_rules! try_none { match $e { Some(e) => e, None => { - return Err(::new( + return Err(<$crate::error::Error as $crate::docfs::PathError>::new( io::Error::new(io::ErrorKind::Other, "not found"), $file, )); diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index 947bae99305a8..90942d87f728f 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -274,7 +274,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> { None }; if let Some(name) = search_name { - add_item_to_search_index(self.tcx, &mut self.cache, &item, name) + add_item_to_search_index(self.tcx, self.cache, &item, name) } // Keep track of the fully qualified path for this item. @@ -452,7 +452,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It // or if item is tuple struct/variant field (name is a number -> not useful for search). if cache.stripped_mod || item.type_() == ItemType::StructField - && name.as_str().chars().all(|c| c.is_digit(10)) + && name.as_str().chars().all(|c| c.is_ascii_digit()) { return; } @@ -463,7 +463,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It } clean::MethodItem(..) | clean::AssocConstItem(..) | clean::AssocTypeItem(..) => { let last = cache.parent_stack.last().expect("parent_stack is empty 2"); - let parent_did = match &*last { + let parent_did = match last { // impl Trait for &T { fn method(self); } // // When generating a function index with the above shape, we want it @@ -471,9 +471,9 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It // show up as `T::method`, rather than `reference::method`, in the search // results page. ParentStackItem::Impl { for_: clean::Type::BorrowedRef { type_, .. }, .. } => { - type_.def_id(&cache) + type_.def_id(cache) } - ParentStackItem::Impl { for_, .. } => for_.def_id(&cache), + ParentStackItem::Impl { for_, .. } => for_.def_id(cache), ParentStackItem::Type(item_id) => item_id.as_def_id(), }; let Some(parent_did) = parent_did else { return }; @@ -538,7 +538,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It None }; let search_type = get_function_type_for_search( - &item, + item, tcx, clean_impl_generics(cache.parent_stack.last()).as_ref(), parent_did, diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 6357cfee141fd..42ab00ea7d155 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -633,7 +633,7 @@ fn generate_item_def_id_path( let module_fqp = to_module_fqp(shortty, &fqp); let mut is_remote = false; - let url_parts = url_parts(cx.cache(), def_id, &module_fqp, &cx.current, &mut is_remote)?; + let url_parts = url_parts(cx.cache(), def_id, module_fqp, &cx.current, &mut is_remote)?; let (url_parts, shortty, fqp) = make_href(root_path, shortty, url_parts, &fqp, is_remote)?; if def_id == original_def_id { return Ok((url_parts, shortty, fqp)); @@ -811,7 +811,7 @@ pub(crate) fn link_tooltip(did: DefId, fragment: &Option, cx: &Cont // primitives are documented in a crate, but not actually part of it &fqp[fqp.len() - 1..] } else { - &fqp + fqp }; if let &Some(UrlFragment::Item(id)) = fragment { write!(buf, "{} ", cx.tcx().def_descr(id)); @@ -820,7 +820,7 @@ pub(crate) fn link_tooltip(did: DefId, fragment: &Option, cx: &Cont } write!(buf, "{}", cx.tcx().item_name(id)); } else if !fqp.is_empty() { - let mut fqp_it = fqp.into_iter(); + let mut fqp_it = fqp.iter(); write!(buf, "{shortty} {}", fqp_it.next().unwrap()); for component in fqp_it { write!(buf, "::{component}"); @@ -830,13 +830,13 @@ pub(crate) fn link_tooltip(did: DefId, fragment: &Option, cx: &Cont } /// Used to render a [`clean::Path`]. -fn resolved_path<'cx>( +fn resolved_path( w: &mut fmt::Formatter<'_>, did: DefId, path: &clean::Path, print_all: bool, use_absolute: bool, - cx: &'cx Context<'_>, + cx: &Context<'_>, ) -> fmt::Result { let last = path.segments.last().unwrap(); @@ -996,11 +996,11 @@ pub(crate) fn anchor<'a, 'cx: 'a>( }) } -fn fmt_type<'cx>( +fn fmt_type( t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool, - cx: &'cx Context<'_>, + cx: &Context<'_>, ) -> fmt::Result { trace!("fmt_type(t = {t:?})"); @@ -1459,9 +1459,8 @@ impl clean::FnDecl { } clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => { write!(f, "{amp}")?; - match lifetime { - Some(lt) => write!(f, "{lt} ", lt = lt.print())?, - None => {} + if let Some(lt) = lifetime { + write!(f, "{lt} ", lt = lt.print())?; } write!(f, "{mutability}self", mutability = mutability.print_with_space())?; }