bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

deindent unsized suggestions

Browse source 
Move stuff out of loops. Use early returns.
This commit is contained in:
Taylor Yu 2021-06-01 20:15:12 -05:00
parent 437b2026e1
commit 69f0dc69a4
1 changed files with 65 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

130
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -1803,51 +1803,51 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
Some(generics) => generics, Some(generics) => generics,
None => return, None => return,
}; };
debug!("suggest_unsized_bound_if_applicable: generics.params={:?}", generics.params); let sized_trait = self.tcx.lang_items().sized_trait();
debug!( debug!("maybe_suggest_unsized_generics: generics.params={:?}", generics.params);
"suggest_unsized_bound_if_applicable: generics.where_clause={:?}", debug!("maybe_suggest_unsized_generics: generics.where_clause={:?}", generics.where_clause);
generics.where_clause let param = generics
); .params
for param in generics.params { .iter()
if param.span != span .filter(|param| param.span == span)
|| param.bounds.iter().any(|bound| { .filter(|param| {
bound.trait_ref().and_then(|trait_ref| trait_ref.trait_def_id()) param
== self.tcx.lang_items().sized_trait() .bounds
}) .iter()
{ .all(|bound| bound.trait_ref().and_then(|tr| tr.trait_def_id()) != sized_trait)
continue; })
} .next();
debug!("maybe_suggest_unsized_generics: param={:?}", param); let param = match param {
match node { Some(param) => param,
hir::Node::Item( _ => return,
item };
@ debug!("maybe_suggest_unsized_generics: param={:?}", param);
hir::Item { match node {
kind: hir::Node::Item(
hir::ItemKind::Enum(..) item
| hir::ItemKind::Struct(..) @
| hir::ItemKind::Union(..), hir::Item {
.. kind:
}, hir::ItemKind::Enum(..) | hir::ItemKind::Struct(..) | hir::ItemKind::Union(..),
) => { ..
if self.maybe_indirection_for_unsized(err, item, param) { },
return; ) => {
} if self.maybe_indirection_for_unsized(err, item, param) {
return;
} }
_ => {}
} }
let (span, separator) = match param.bounds { _ => {}
[] => (span.shrink_to_hi(), ":"), };
[.., bound] => (bound.span().shrink_to_hi(), " +"), let (span, separator) = match param.bounds {
}; [] => (span.shrink_to_hi(), ":"),
err.span_suggestion_verbose( [.., bound] => (bound.span().shrink_to_hi(), " +"),
span, };
"consider relaxing the implicit `Sized` restriction", err.span_suggestion_verbose(
format!("{} ?Sized", separator), span,
Applicability::MachineApplicable, "consider relaxing the implicit `Sized` restriction",
); format!("{} ?Sized", separator),
return; Applicability::MachineApplicable,
} );
} }
fn maybe_indirection_for_unsized( fn maybe_indirection_for_unsized(
@ -1862,29 +1862,29 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
let mut visitor = let mut visitor =
FindTypeParam { param: param.name.ident().name, invalid_spans: vec![], nested: false }; FindTypeParam { param: param.name.ident().name, invalid_spans: vec![], nested: false };
visitor.visit_item(item); visitor.visit_item(item);
if !visitor.invalid_spans.is_empty() { if visitor.invalid_spans.is_empty() {
let mut multispan: MultiSpan = param.span.into(); return false;
multispan.push_span_label(
param.span,
format!("this could be changed to `{}: ?Sized`...", param.name.ident()),
);
for sp in visitor.invalid_spans {
multispan.push_span_label(
sp,
format!("...if indirection were used here: `Box<{}>`", param.name.ident()),
);
}
err.span_help(
multispan,
&format!(
"you could relax the implicit `Sized` bound on `{T}` if it were \
used through indirection like `&{T}` or `Box<{T}>`",
T = param.name.ident(),
),
);
return true;
} }
false let mut multispan: MultiSpan = param.span.into();
multispan.push_span_label(
param.span,
format!("this could be changed to `{}: ?Sized`...", param.name.ident()),
);
for sp in visitor.invalid_spans {
multispan.push_span_label(
sp,
format!("...if indirection were used here: `Box<{}>`", param.name.ident()),
);
}
err.span_help(
multispan,
&format!(
"you could relax the implicit `Sized` bound on `{T}` if it were \
used through indirection like `&{T}` or `Box<{T}>`",
T = param.name.ident(),
),
);
true
} }
fn is_recursive_obligation( fn is_recursive_obligation(