bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

fix more clippy::style findings

Browse source 
match_result_ok
obfuscated_if_else
single_char_add
writeln_empty_string
collapsible_match
iter_cloned_collect
unnecessary_mut_passed
This commit is contained in:
Matthias Krüger 2022-12-25 16:42:35 +01:00
parent d9ee0f468f
commit d8874f259a
16 changed files with 73 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_ast_lowering/src/item.rs
View file

@ -259,8 +259,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
body.as_deref(), body.as_deref(),
); );
let mut itctx = ImplTraitContext::Universal; let itctx = ImplTraitContext::Universal;
let (generics, decl) = this.lower_generics(generics, id, &mut itctx, |this| { let (generics, decl) = this.lower_generics(generics, id, &itctx, |this| {
let ret_id = asyncness.opt_return_id(); let ret_id = asyncness.opt_return_id();
this.lower_fn_decl(&decl, id, *fn_sig_span, FnDeclKind::Fn, ret_id) this.lower_fn_decl(&decl, id, *fn_sig_span, FnDeclKind::Fn, ret_id)
}); });
@ -369,9 +369,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
// method, it will not be considered an in-band // method, it will not be considered an in-band
// lifetime to be added, but rather a reference to a // lifetime to be added, but rather a reference to a
// parent lifetime. // parent lifetime.
let mut itctx = ImplTraitContext::Universal; let itctx = ImplTraitContext::Universal;
let (generics, (trait_ref, lowered_ty)) = let (generics, (trait_ref, lowered_ty)) =
self.lower_generics(ast_generics, id, &mut itctx, |this| { self.lower_generics(ast_generics, id, &itctx, |this| {
let trait_ref = trait_ref.as_ref().map(|trait_ref| { let trait_ref = trait_ref.as_ref().map(|trait_ref| {
this.lower_trait_ref( this.lower_trait_ref(
trait_ref, trait_ref,
@ -590,9 +590,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
kind: match &i.kind { kind: match &i.kind {
ForeignItemKind::Fn(box Fn { sig, generics, .. }) => { ForeignItemKind::Fn(box Fn { sig, generics, .. }) => {
let fdec = &sig.decl; let fdec = &sig.decl;
let mut itctx = ImplTraitContext::Universal; let itctx = ImplTraitContext::Universal;
let (generics, (fn_dec, fn_args)) = let (generics, (fn_dec, fn_args)) =
self.lower_generics(generics, i.id, &mut itctx, |this| { self.lower_generics(generics, i.id, &itctx, |this| {
( (
// Disallow `impl Trait` in foreign items. // Disallow `impl Trait` in foreign items.
this.lower_fn_decl( this.lower_fn_decl(
@ -1184,8 +1184,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
is_async: Option<(NodeId, Span)>, is_async: Option<(NodeId, Span)>,
) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) { ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) {
let header = self.lower_fn_header(sig.header); let header = self.lower_fn_header(sig.header);
let mut itctx = ImplTraitContext::Universal; let itctx = ImplTraitContext::Universal;
let (generics, decl) = self.lower_generics(generics, id, &mut itctx, |this| { let (generics, decl) = self.lower_generics(generics, id, &itctx, |this| {
this.lower_fn_decl(&sig.decl, id, sig.span, kind, is_async) this.lower_fn_decl(&sig.decl, id, sig.span, kind, is_async)
}); });
(generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) }) (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })

4
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -2031,7 +2031,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self, &mut self,
output: &FnRetTy, output: &FnRetTy,
span: Span, span: Span,
mut nested_impl_trait_context: ImplTraitContext, nested_impl_trait_context: ImplTraitContext,
) -> hir::GenericBound<'hir> { ) -> hir::GenericBound<'hir> {
// Compute the `T` in `Future<Output = T>` from the return type. // Compute the `T` in `Future<Output = T>` from the return type.
let output_ty = match output { let output_ty = match output {
@ -2039,7 +2039,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Not `OpaqueTyOrigin::AsyncFn`: that's only used for the // Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
// `impl Future` opaque type that `async fn` implicitly // `impl Future` opaque type that `async fn` implicitly
// generates. // generates.
self.lower_ty(ty, &mut nested_impl_trait_context) self.lower_ty(ty, &nested_impl_trait_context)
} }
FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])), FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
}; };

6
compiler/rustc_ast_lowering/src/pat.rs
View file

@ -37,7 +37,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself, qself,
path, path,
ParamMode::Optional, ParamMode::Optional,
&mut ImplTraitContext::Disallowed(ImplTraitPosition::Path), &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
); );
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct"); let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
break hir::PatKind::TupleStruct(qpath, pats, ddpos); break hir::PatKind::TupleStruct(qpath, pats, ddpos);
@ -53,7 +53,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself, qself,
path, path,
ParamMode::Optional, ParamMode::Optional,
&mut ImplTraitContext::Disallowed(ImplTraitPosition::Path), &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
); );
break hir::PatKind::Path(qpath); break hir::PatKind::Path(qpath);
} }
@ -63,7 +63,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself, qself,
path, path,
ParamMode::Optional, ParamMode::Optional,
&mut ImplTraitContext::Disallowed(ImplTraitPosition::Path), &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
); );
let fs = self.arena.alloc_from_iter(fields.iter().map(|f| { let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {

43
compiler/rustc_borrowck/src/type_check/input_output.rs
View file

@ -37,31 +37,30 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
// those. // those.
// //
// e.g., `|x: FxHashMap<_, &'static u32>| ...` // e.g., `|x: FxHashMap<_, &'static u32>| ...`
let user_provided_sig; let user_provided_sig = if !self.tcx().is_closure(mir_def_id.to_def_id()) {
if !self.tcx().is_closure(mir_def_id.to_def_id()) { None
user_provided_sig = None;
} else { } else {
let typeck_results = self.tcx().typeck(mir_def_id); let typeck_results = self.tcx().typeck(mir_def_id);
user_provided_sig =
typeck_results.user_provided_sigs.get(&mir_def_id).map(|user_provided_poly_sig| {
// Instantiate the canonicalized variables from
// user-provided signature (e.g., the `_` in the code
// above) with fresh variables.
let poly_sig = self.instantiate_canonical_with_fresh_inference_vars(
body.span,
&user_provided_poly_sig,
);
// Replace the bound items in the fn sig with fresh typeck_results.user_provided_sigs.get(&mir_def_id).map(|user_provided_poly_sig| {
// variables, so that they represent the view from // Instantiate the canonicalized variables from
// "inside" the closure. // user-provided signature (e.g., the `_` in the code
self.infcx.replace_bound_vars_with_fresh_vars( // above) with fresh variables.
body.span, let poly_sig = self.instantiate_canonical_with_fresh_inference_vars(
LateBoundRegionConversionTime::FnCall, body.span,
poly_sig, &user_provided_poly_sig,
) );
});
} // Replace the bound items in the fn sig with fresh
// variables, so that they represent the view from
// "inside" the closure.
self.infcx.replace_bound_vars_with_fresh_vars(
body.span,
LateBoundRegionConversionTime::FnCall,
poly_sig,
)
})
};
debug!(?normalized_input_tys, ?body.local_decls); debug!(?normalized_input_tys, ?body.local_decls);

2
compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
View file

@ -509,7 +509,7 @@ pub fn compute_debuginfo_vtable_name<'tcx>(
visited.clear(); visited.clear();
push_generic_params_internal(tcx, trait_ref.substs, &mut vtable_name, &mut visited); push_generic_params_internal(tcx, trait_ref.substs, &mut vtable_name, &mut visited);
} else { } else {
vtable_name.push_str("_"); vtable_name.push('_');
} }
push_close_angle_bracket(cpp_like_debuginfo, &mut vtable_name); push_close_angle_bracket(cpp_like_debuginfo, &mut vtable_name);

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

@ -653,7 +653,7 @@ fn print_crate_info(
for req in &sess.opts.prints { for req in &sess.opts.prints {
match *req { match *req {
TargetList => { TargetList => {
let mut targets = rustc_target::spec::TARGETS.iter().copied().collect::<Vec<_>>(); let mut targets = rustc_target::spec::TARGETS.to_vec();
targets.sort_unstable(); targets.sort_unstable();
println!("{}", targets.join("\n")); println!("{}", targets.join("\n"));
} }

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

@ -1212,8 +1212,8 @@ impl HandlerInner {
self.taught_diagnostics.insert(code.clone()) self.taught_diagnostics.insert(code.clone())
} }
fn force_print_diagnostic(&mut self, mut db: Diagnostic) { fn force_print_diagnostic(&mut self, db: Diagnostic) {
self.emitter.emit_diagnostic(&mut db); self.emitter.emit_diagnostic(&db);
} }
/// Emit all stashed diagnostics. /// Emit all stashed diagnostics.

6
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

@ -1166,11 +1166,7 @@ fn check_matcher_core<'tt>(
err.note(&format!( err.note(&format!(
"{}{} or {}", "{}{} or {}",
msg, msg,
ts[..ts.len() - 1] ts[..ts.len() - 1].to_vec().join(", "),
.iter()
.copied()
.collect::<Vec<_>>()
.join(", "),
ts[ts.len() - 1], ts[ts.len() - 1],
)); ));
} }

5
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View file

@ -410,10 +410,7 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, associated_items: &[hir::TraitItemRe
tcx, tcx,
param_env, param_env,
item_hir_id, item_hir_id,
tcx.explicit_item_bounds(item_def_id) tcx.explicit_item_bounds(item_def_id).to_vec(),
.iter()
.copied()
.collect::<Vec<_>>(),
&FxIndexSet::default(), &FxIndexSet::default(),
gat_def_id.def_id, gat_def_id.def_id,
gat_generics, gat_generics,

14
compiler/rustc_lint/src/context.rs
View file

@ -355,14 +355,12 @@ impl LintStore {
sub: RequestedLevel { level, lint_name }, sub: RequestedLevel { level, lint_name },
}); });
} }
CheckLintNameResult::Tool(result) => { CheckLintNameResult::Tool(Err((Some(_), new_name))) => {
if let Err((Some(_), new_name)) = result { sess.emit_warning(CheckNameDeprecated {
sess.emit_warning(CheckNameDeprecated { lint_name: lint_name.clone(),
lint_name: lint_name.clone(), new_name,
new_name, sub: RequestedLevel { level, lint_name },
sub: RequestedLevel { level, lint_name }, });
});
}
} }
CheckLintNameResult::NoTool => { CheckLintNameResult::NoTool => {
sess.emit_err(CheckNameUnknownTool { sess.emit_err(CheckNameUnknownTool {

2
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -1564,7 +1564,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let trait_ref = self.tcx.impl_trait_ref(def_id); let trait_ref = self.tcx.impl_trait_ref(def_id);
if let Some(trait_ref) = trait_ref { if let Some(trait_ref) = trait_ref {
let trait_def = self.tcx.trait_def(trait_ref.def_id); let trait_def = self.tcx.trait_def(trait_ref.def_id);
if let Some(mut an) = trait_def.ancestors(self.tcx, def_id).ok() { if let Ok(mut an) = trait_def.ancestors(self.tcx, def_id) {
if let Some(specialization_graph::Node::Impl(parent)) = an.nth(1) { if let Some(specialization_graph::Node::Impl(parent)) = an.nth(1) {
self.tables.impl_parent.set(def_id.index, parent.into()); self.tables.impl_parent.set(def_id.index, parent.into());
} }

10
compiler/rustc_middle/src/hir/map/mod.rs
View file

@ -704,12 +704,10 @@ impl<'hir> Map<'hir> {
pub fn get_return_block(self, id: HirId) -> Option<HirId> { pub fn get_return_block(self, id: HirId) -> Option<HirId> {
let mut iter = self.parent_iter(id).peekable(); let mut iter = self.parent_iter(id).peekable();
let mut ignore_tail = false; let mut ignore_tail = false;
if let Some(node) = self.find(id) { if let Some(Node::Expr(Expr { kind: ExprKind::Ret(_), .. })) = self.find(id) {
if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = node { // When dealing with `return` statements, we don't care about climbing only tail
// When dealing with `return` statements, we don't care about climbing only tail // expressions.
// expressions. ignore_tail = true;
ignore_tail = true;
}
} }
while let Some((hir_id, node)) = iter.next() { while let Some((hir_id, node)) = iter.next() {
if let (Some((_, next_node)), false) = (iter.peek(), ignore_tail) { if let (Some((_, next_node)), false) = (iter.peek(), ignore_tail) {

2
compiler/rustc_middle/src/mir/mod.rs
View file

@ -2894,7 +2894,7 @@ fn pretty_print_const_value<'tcx>(
if let Some(contents) = tcx.try_destructure_mir_constant( if let Some(contents) = tcx.try_destructure_mir_constant(
ty::ParamEnv::reveal_all().and(ConstantKind::Val(ct, ty)), ty::ParamEnv::reveal_all().and(ConstantKind::Val(ct, ty)),
) { ) {
let fields = contents.fields.iter().copied().collect::<Vec<_>>(); let fields = contents.fields.to_vec();
match *ty.kind() { match *ty.kind() {
ty::Array(..) => { ty::Array(..) => {
fmt.write_str("[")?; fmt.write_str("[")?;

2
compiler/rustc_monomorphize/src/partitioning/mod.rs
View file

@ -305,7 +305,7 @@ where
); );
} }
let _ = writeln!(s, ""); let _ = writeln!(s);
} }
std::mem::take(s) std::mem::take(s)

4
compiler/rustc_passes/src/check_attr.rs
View file

@ -1090,9 +1090,7 @@ impl CheckAttrVisitor<'_> {
errors::DocTestUnknownInclude { errors::DocTestUnknownInclude {
path, path,
value: value.to_string(), value: value.to_string(),
inner: (attr.style == AttrStyle::Inner) inner: if attr.style == AttrStyle::Inner { "!" } else { "" },
.then_some("!")
.unwrap_or(""),
sugg: (attr.meta().unwrap().span, applicability), sugg: (attr.meta().unwrap().span, applicability),
} }
); );

43
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -1291,29 +1291,25 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
if let ObligationCauseCode::AwaitableExpr(hir_id) = obligation.cause.code().peel_derives() { if let ObligationCauseCode::AwaitableExpr(hir_id) = obligation.cause.code().peel_derives() {
let hir = self.tcx.hir(); let hir = self.tcx.hir();
if let Some(node) = hir_id.and_then(|hir_id| hir.find(hir_id)) { if let Some(hir::Node::Expr(expr)) = hir_id.and_then(|hir_id| hir.find(hir_id)) {
if let hir::Node::Expr(expr) = node { // FIXME: use `obligation.predicate.kind()...trait_ref.self_ty()` to see if we have `()`
// FIXME: use `obligation.predicate.kind()...trait_ref.self_ty()` to see if we have `()` // and if not maybe suggest doing something else? If we kept the expression around we
// and if not maybe suggest doing something else? If we kept the expression around we // could also check if it is an fn call (very likely) and suggest changing *that*, if
// could also check if it is an fn call (very likely) and suggest changing *that*, if // it is from the local crate.
// it is from the local crate. err.span_suggestion(
err.span_suggestion( span,
span, "remove the `.await`",
"remove the `.await`", "",
"", Applicability::MachineApplicable,
Applicability::MachineApplicable, );
); // FIXME: account for associated `async fn`s.
// FIXME: account for associated `async fn`s. if let hir::Expr { span, kind: hir::ExprKind::Call(base, _), .. } = expr {
if let hir::Expr { span, kind: hir::ExprKind::Call(base, _), .. } = expr { if let ty::PredicateKind::Clause(ty::Clause::Trait(pred)) =
if let ty::PredicateKind::Clause(ty::Clause::Trait(pred)) = obligation.predicate.kind().skip_binder()
obligation.predicate.kind().skip_binder() {
{ err.span_label(*span, &format!("this call returns `{}`", pred.self_ty()));
err.span_label( }
*span, if let Some(typeck_results) = &self.typeck_results
&format!("this call returns `{}`", pred.self_ty()),
);
}
if let Some(typeck_results) = &self.typeck_results
&& let ty = typeck_results.expr_ty_adjusted(base) && let ty = typeck_results.expr_ty_adjusted(base)
&& let ty::FnDef(def_id, _substs) = ty.kind() && let ty::FnDef(def_id, _substs) = ty.kind()
&& let Some(hir::Node::Item(hir::Item { ident, span, vis_span, .. })) = && let Some(hir::Node::Item(hir::Item { ident, span, vis_span, .. })) =
@ -1339,7 +1335,6 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
); );
} }
} }
}
} }
} }
} }