nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-29 10:13:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace enum ==s with matches where it makes sense

Browse Source
This commit is contained in:
Maybe Waffle 2023-01-30 11:03:32 +00:00
parent f55b0022db
commit fd649a3cc5
16 changed files with 258 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
compiler/rustc_ast/src/util/comments.rs
View File

@ -58,23 +58,24 @@ pub fn beautify_doc_string(data: Symbol, kind: CommentKind) -> Symbol {
// In case we have doc comments like `/**` or `/*!`, we want to remove stars if they are // In case we have doc comments like `/**` or `/*!`, we want to remove stars if they are
// present. However, we first need to strip the empty lines so they don't get in the middle // present. However, we first need to strip the empty lines so they don't get in the middle
// when we try to compute the "horizontal trim". // when we try to compute the "horizontal trim".
let lines = if kind == CommentKind::Block { let lines = match kind {
// Whatever happens, we skip the first line. CommentKind::Block => {
let mut i = lines // Whatever happens, we skip the first line.
.get(0) let mut i = lines
.map(|l| if l.trim_start().starts_with('*') { 0 } else { 1 }) .get(0)
.unwrap_or(0); .map(|l| if l.trim_start().starts_with('*') { 0 } else { 1 })
let mut j = lines.len(); .unwrap_or(0);
let mut j = lines.len();
while i < j && lines[i].trim().is_empty() { while i < j && lines[i].trim().is_empty() {
i += 1; i += 1;
}
while j > i && lines[j - 1].trim().is_empty() {
j -= 1;
}
&lines[i..j]
} }
while j > i && lines[j - 1].trim().is_empty() { CommentKind::Line => lines,
j -= 1;
}
&lines[i..j]
} else {
lines
}; };
for line in lines { for line in lines {

7
compiler/rustc_const_eval/src/const_eval/machine.rs
View File

@ -622,10 +622,9 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
let alloc = alloc.inner(); let alloc = alloc.inner();
if is_write { if is_write {
// Write access. These are never allowed, but we give a targeted error message. // Write access. These are never allowed, but we give a targeted error message.
if alloc.mutability == Mutability::Not { match alloc.mutability {
Err(err_ub!(WriteToReadOnly(alloc_id)).into()) Mutability::Not => Err(err_ub!(WriteToReadOnly(alloc_id)).into()),
} else { Mutability::Mut => Err(ConstEvalErrKind::ModifiedGlobal.into()),
Err(ConstEvalErrKind::ModifiedGlobal.into())
} }
} else { } else {
// Read access. These are usually allowed, with some exceptions. // Read access. These are usually allowed, with some exceptions.

54
compiler/rustc_errors/src/emitter.rs
View File

@ -2113,30 +2113,38 @@ impl EmitterWriter {
} }
} }
for sugg in suggestions { for sugg in suggestions {
if sugg.style == SuggestionStyle::CompletelyHidden { match sugg.style {
// do not display this suggestion, it is meant only for tools SuggestionStyle::CompletelyHidden => {
} else if sugg.style == SuggestionStyle::HideCodeAlways { // do not display this suggestion, it is meant only for tools
if let Err(e) = self.emit_message_default(
&MultiSpan::new(),
&[(sugg.msg.to_owned(), Style::HeaderMsg)],
args,
&None,
&Level::Help,
max_line_num_len,
true,
None,
) {
panic!("failed to emit error: {}", e);
} }
} else if let Err(e) = self.emit_suggestion_default( SuggestionStyle::HideCodeAlways => {
span, if let Err(e) = self.emit_message_default(
sugg, &MultiSpan::new(),
args, &[(sugg.msg.to_owned(), Style::HeaderMsg)],
&Level::Help, args,
max_line_num_len, &None,
) { &Level::Help,
panic!("failed to emit error: {}", e); max_line_num_len,
}; true,
None,
) {
panic!("failed to emit error: {}", e);
}
}
SuggestionStyle::HideCodeInline
| SuggestionStyle::ShowCode
| SuggestionStyle::ShowAlways => {
if let Err(e) = self.emit_suggestion_default(
span,
sugg,
args,
&Level::Help,
max_line_num_len,
) {
panic!("failed to emit error: {}", e);
}
}
}
} }
} }
} }

7
compiler/rustc_hir_analysis/src/astconv/generics.rs
View File

@ -385,10 +385,9 @@ pub fn check_generic_arg_count_for_call(
) -> GenericArgCountResult { ) -> GenericArgCountResult {
let empty_args = hir::GenericArgs::none(); let empty_args = hir::GenericArgs::none();
let gen_args = seg.args.unwrap_or(&empty_args); let gen_args = seg.args.unwrap_or(&empty_args);
let gen_pos = if is_method_call == IsMethodCall::Yes { let gen_pos = match is_method_call {
GenericArgPosition::MethodCall IsMethodCall::Yes => GenericArgPosition::MethodCall,
} else { IsMethodCall::No => GenericArgPosition::Value,
GenericArgPosition::Value
}; };
let has_self = generics.parent.is_none() && generics.has_self; let has_self = generics.parent.is_none() && generics.has_self;

105
compiler/rustc_hir_analysis/src/check/check.rs
View File

@ -605,59 +605,66 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
}; };
check_abi(tcx, it.hir_id(), it.span, abi); check_abi(tcx, it.hir_id(), it.span, abi);
if abi == Abi::RustIntrinsic { match abi {
for item in items { Abi::RustIntrinsic => {
let item = tcx.hir().foreign_item(item.id); for item in items {
intrinsic::check_intrinsic_type(tcx, item); let item = tcx.hir().foreign_item(item.id);
} intrinsic::check_intrinsic_type(tcx, item);
} else if abi == Abi::PlatformIntrinsic {
for item in items {
let item = tcx.hir().foreign_item(item.id);
intrinsic::check_platform_intrinsic_type(tcx, item);
}
} else {
for item in items {
let def_id = item.id.owner_id.def_id;
let generics = tcx.generics_of(def_id);
let own_counts = generics.own_counts();
if generics.params.len() - own_counts.lifetimes != 0 {
let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
(_, 0) => ("type", "types", Some("u32")),
// We don't specify an example value, because we can't generate
// a valid value for any type.
(0, _) => ("const", "consts", None),
_ => ("type or const", "types or consts", None),
};
struct_span_err!(
tcx.sess,
item.span,
E0044,
"foreign items may not have {kinds} parameters",
)
.span_label(item.span, &format!("can't have {kinds} parameters"))
.help(
// FIXME: once we start storing spans for type arguments, turn this
// into a suggestion.
&format!(
"replace the {} parameters with concrete {}{}",
kinds,
kinds_pl,
egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
),
)
.emit();
} }
}
let item = tcx.hir().foreign_item(item.id); Abi::PlatformIntrinsic => {
match &item.kind { for item in items {
hir::ForeignItemKind::Fn(fn_decl, _, _) => { let item = tcx.hir().foreign_item(item.id);
require_c_abi_if_c_variadic(tcx, fn_decl, abi, item.span); intrinsic::check_platform_intrinsic_type(tcx, item);
}
}
_ => {
for item in items {
let def_id = item.id.owner_id.def_id;
let generics = tcx.generics_of(def_id);
let own_counts = generics.own_counts();
if generics.params.len() - own_counts.lifetimes != 0 {
let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts)
{
(_, 0) => ("type", "types", Some("u32")),
// We don't specify an example value, because we can't generate
// a valid value for any type.
(0, _) => ("const", "consts", None),
_ => ("type or const", "types or consts", None),
};
struct_span_err!(
tcx.sess,
item.span,
E0044,
"foreign items may not have {kinds} parameters",
)
.span_label(item.span, &format!("can't have {kinds} parameters"))
.help(
// FIXME: once we start storing spans for type arguments, turn this
// into a suggestion.
&format!(
"replace the {} parameters with concrete {}{}",
kinds,
kinds_pl,
egs.map(|egs| format!(" like `{}`", egs)).unwrap_or_default(),
),
)
.emit();
} }
hir::ForeignItemKind::Static(..) => {
check_static_inhabited(tcx, def_id); let item = tcx.hir().foreign_item(item.id);
check_static_linkage(tcx, def_id); match &item.kind {
hir::ForeignItemKind::Fn(fn_decl, _, _) => {
require_c_abi_if_c_variadic(tcx, fn_decl, abi, item.span);
}
hir::ForeignItemKind::Static(..) => {
check_static_inhabited(tcx, def_id);
check_static_linkage(tcx, def_id);
}
_ => {}
} }
_ => {}
} }
} }
} }

7
compiler/rustc_hir_typeck/src/method/probe.rs
View File

@ -1354,13 +1354,12 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
return Some(Err(MethodError::Ambiguity(sources))); return Some(Err(MethodError::Ambiguity(sources)));
} }
applicable_candidates.pop().map(|(probe, status)| { applicable_candidates.pop().map(|(probe, status)| match status {
if status == ProbeResult::Match { ProbeResult::Match => {
Ok(probe Ok(probe
.to_unadjusted_pick(self_ty, unstable_candidates.cloned().unwrap_or_default())) .to_unadjusted_pick(self_ty, unstable_candidates.cloned().unwrap_or_default()))
} else {
Err(MethodError::BadReturnType)
} }
ProbeResult::NoMatch | ProbeResult::BadReturnType => Err(MethodError::BadReturnType),
}) })
} }
} }

41
compiler/rustc_lint/src/builtin.rs
View File

@ -580,27 +580,28 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
} }
fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) { fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
// If the method is an impl for a trait, don't doc.
let context = method_context(cx, impl_item.owner_id.def_id); let context = method_context(cx, impl_item.owner_id.def_id);
if context == MethodLateContext::TraitImpl {
return; match context {
} // If the method is an impl for a trait, don't doc.
MethodLateContext::TraitImpl => return,
// If the method is an impl for an item with docs_hidden, don't doc. MethodLateContext::TraitAutoImpl => {}
if context == MethodLateContext::PlainImpl { // If the method is an impl for an item with docs_hidden, don't doc.
let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id()); MethodLateContext::PlainImpl => {
let impl_ty = cx.tcx.type_of(parent); let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id());
let outerdef = match impl_ty.kind() { let impl_ty = cx.tcx.type_of(parent);
ty::Adt(def, _) => Some(def.did()), let outerdef = match impl_ty.kind() {
ty::Foreign(def_id) => Some(*def_id), ty::Adt(def, _) => Some(def.did()),
_ => None, ty::Foreign(def_id) => Some(*def_id),
}; _ => None,
let is_hidden = match outerdef { };
Some(id) => cx.tcx.is_doc_hidden(id), let is_hidden = match outerdef {
None => false, Some(id) => cx.tcx.is_doc_hidden(id),
}; None => false,
if is_hidden { };
return; if is_hidden {
return;
}
} }
} }

65
compiler/rustc_metadata/src/dependency_format.rs
View File

@ -113,37 +113,37 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
CrateType::Staticlib => Linkage::Static, CrateType::Staticlib => Linkage::Static,
}; };
if preferred_linkage == Linkage::NotLinked { match preferred_linkage {
// If the crate is not linked, there are no link-time dependencies. // If the crate is not linked, there are no link-time dependencies.
return Vec::new(); Linkage::NotLinked => return Vec::new(),
} Linkage::Static => {
// Attempt static linkage first. For dylibs and executables, we may be
if preferred_linkage == Linkage::Static { // able to retry below with dynamic linkage.
// Attempt static linkage first. For dylibs and executables, we may be if let Some(v) = attempt_static(tcx) {
// able to retry below with dynamic linkage. return v;
if let Some(v) = attempt_static(tcx) { }
return v;
} // Staticlibs and static executables must have all static dependencies.
// If any are not found, generate some nice pretty errors.
// Staticlibs and static executables must have all static dependencies. if ty == CrateType::Staticlib
// If any are not found, generate some nice pretty errors. || (ty == CrateType::Executable
if ty == CrateType::Staticlib && sess.crt_static(Some(ty))
|| (ty == CrateType::Executable && !sess.target.crt_static_allows_dylibs)
&& sess.crt_static(Some(ty)) {
&& !sess.target.crt_static_allows_dylibs) for &cnum in tcx.crates(()).iter() {
{ if tcx.dep_kind(cnum).macros_only() {
for &cnum in tcx.crates(()).iter() { continue;
if tcx.dep_kind(cnum).macros_only() { }
continue; let src = tcx.used_crate_source(cnum);
} if src.rlib.is_some() {
let src = tcx.used_crate_source(cnum); continue;
if src.rlib.is_some() { }
continue; sess.emit_err(RlibRequired { crate_name: tcx.crate_name(cnum) });
} }
sess.emit_err(RlibRequired { crate_name: tcx.crate_name(cnum) }); return Vec::new();
} }
return Vec::new();
} }
Linkage::Dynamic | Linkage::IncludedFromDylib => {}
} }
let mut formats = FxHashMap::default(); let mut formats = FxHashMap::default();
@ -283,12 +283,9 @@ fn attempt_static(tcx: TyCtxt<'_>) -> Option<DependencyList> {
let mut ret = tcx let mut ret = tcx
.crates(()) .crates(())
.iter() .iter()
.map(|&cnum| { .map(|&cnum| match tcx.dep_kind(cnum) {
if tcx.dep_kind(cnum) == CrateDepKind::Explicit { CrateDepKind::Explicit => Linkage::Static,
Linkage::Static CrateDepKind::MacrosOnly | CrateDepKind::Implicit => Linkage::NotLinked,
} else {
Linkage::NotLinked
}
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();

5
compiler/rustc_middle/src/mir/coverage.rs
View File

@ -135,7 +135,10 @@ impl Debug for CoverageKind {
"Expression({:?}) = {} {} {}", "Expression({:?}) = {} {} {}",
id.index(), id.index(),
lhs.index(), lhs.index(),
if *op == Op::Add { "+" } else { "-" }, match op {
Op::Add => "+",
Op::Subtract => "-",
},
rhs.index(), rhs.index(),
), ),
Unreachable => write!(fmt, "Unreachable"), Unreachable => write!(fmt, "Unreachable"),

5
compiler/rustc_mir_transform/src/coverage/debug.rs
View File

@ -323,7 +323,10 @@ impl DebugCounters {
String::new() String::new()
}, },
self.format_operand(lhs), self.format_operand(lhs),
if op == Op::Add { "+" } else { "-" }, match op {
Op::Add => "+",
Op::Subtract => "-",
},
self.format_operand(rhs), self.format_operand(rhs),
); );
} }

22
compiler/rustc_parse/src/parser/stmt.rs
View File

@ -93,11 +93,12 @@ impl<'a> Parser<'a> {
// or `auto trait` items. We aim to parse an arbitrary path `a::b` but not something // or `auto trait` items. We aim to parse an arbitrary path `a::b` but not something
// that starts like a path (1 token), but it fact not a path. // that starts like a path (1 token), but it fact not a path.
// Also, we avoid stealing syntax from `parse_item_`. // Also, we avoid stealing syntax from `parse_item_`.
if force_collect == ForceCollect::Yes { match force_collect {
self.collect_tokens_no_attrs(|this| this.parse_stmt_path_start(lo, attrs)) ForceCollect::Yes => {
} else { self.collect_tokens_no_attrs(|this| this.parse_stmt_path_start(lo, attrs))?
self.parse_stmt_path_start(lo, attrs) }
}? ForceCollect::No => self.parse_stmt_path_start(lo, attrs)?,
}
} else if let Some(item) = self.parse_item_common( } else if let Some(item) = self.parse_item_common(
attrs.clone(), attrs.clone(),
false, false,
@ -113,13 +114,12 @@ impl<'a> Parser<'a> {
self.mk_stmt(lo, StmtKind::Empty) self.mk_stmt(lo, StmtKind::Empty)
} else if self.token != token::CloseDelim(Delimiter::Brace) { } else if self.token != token::CloseDelim(Delimiter::Brace) {
// Remainder are line-expr stmts. // Remainder are line-expr stmts.
let e = if force_collect == ForceCollect::Yes { let e = match force_collect {
self.collect_tokens_no_attrs(|this| { ForceCollect::Yes => self.collect_tokens_no_attrs(|this| {
this.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs)) this.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs))
}) })?,
} else { ForceCollect::No => self.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs))?,
self.parse_expr_res(Restrictions::STMT_EXPR, Some(attrs)) };
}?;
if matches!(e.kind, ExprKind::Assign(..)) && self.eat_keyword(kw::Else) { if matches!(e.kind, ExprKind::Assign(..)) && self.eat_keyword(kw::Else) {
let bl = self.parse_block()?; let bl = self.parse_block()?;
// Destructuring assignment ... else. // Destructuring assignment ... else.

22
compiler/rustc_parse/src/parser/ty.rs
View File

@ -323,13 +323,14 @@ impl<'a> Parser<'a> {
} else if self.can_begin_bound() { } else if self.can_begin_bound() {
self.parse_bare_trait_object(lo, allow_plus)? self.parse_bare_trait_object(lo, allow_plus)?
} else if self.eat(&token::DotDotDot) { } else if self.eat(&token::DotDotDot) {
if allow_c_variadic == AllowCVariadic::Yes { match allow_c_variadic {
TyKind::CVarArgs AllowCVariadic::Yes => TyKind::CVarArgs,
} else { AllowCVariadic::No => {
// FIXME(Centril): Should we just allow `...` syntactically // FIXME(Centril): Should we just allow `...` syntactically
// anywhere in a type and use semantic restrictions instead? // anywhere in a type and use semantic restrictions instead?
self.error_illegal_c_varadic_ty(lo); self.error_illegal_c_varadic_ty(lo);
TyKind::Err TyKind::Err
}
} }
} else { } else {
let msg = format!("expected type, found {}", super::token_descr(&self.token)); let msg = format!("expected type, found {}", super::token_descr(&self.token));
@ -343,10 +344,9 @@ impl<'a> Parser<'a> {
let mut ty = self.mk_ty(span, kind); let mut ty = self.mk_ty(span, kind);
// Try to recover from use of `+` with incorrect priority. // Try to recover from use of `+` with incorrect priority.
if allow_plus == AllowPlus::Yes { match allow_plus {
self.maybe_recover_from_bad_type_plus(&ty)?; AllowPlus::Yes => self.maybe_recover_from_bad_type_plus(&ty)?,
} else { AllowPlus::No => self.maybe_report_ambiguous_plus(impl_dyn_multi, &ty),
self.maybe_report_ambiguous_plus(impl_dyn_multi, &ty);
} }
if RecoverQuestionMark::Yes == recover_question_mark { if RecoverQuestionMark::Yes == recover_question_mark {
ty = self.maybe_recover_from_question_mark(ty); ty = self.maybe_recover_from_question_mark(ty);

58
compiler/rustc_passes/src/check_attr.rs
View File

@ -864,33 +864,39 @@ impl CheckAttrVisitor<'_> {
target: Target, target: Target,
specified_inline: &mut Option<(bool, Span)>, specified_inline: &mut Option<(bool, Span)>,
) -> bool { ) -> bool {
if target == Target::Use || target == Target::ExternCrate { match target {
let do_inline = meta.name_or_empty() == sym::inline; Target::Use | Target::ExternCrate => {
if let Some((prev_inline, prev_span)) = *specified_inline { let do_inline = meta.name_or_empty() == sym::inline;
if do_inline != prev_inline { if let Some((prev_inline, prev_span)) = *specified_inline {
let mut spans = MultiSpan::from_spans(vec![prev_span, meta.span()]); if do_inline != prev_inline {
spans.push_span_label(prev_span, fluent::passes_doc_inline_conflict_first); let mut spans = MultiSpan::from_spans(vec![prev_span, meta.span()]);
spans.push_span_label(meta.span(), fluent::passes_doc_inline_conflict_second); spans.push_span_label(prev_span, fluent::passes_doc_inline_conflict_first);
self.tcx.sess.emit_err(errors::DocKeywordConflict { spans }); spans.push_span_label(
return false; meta.span(),
fluent::passes_doc_inline_conflict_second,
);
self.tcx.sess.emit_err(errors::DocKeywordConflict { spans });
return false;
}
true
} else {
*specified_inline = Some((do_inline, meta.span()));
true
} }
true
} else {
*specified_inline = Some((do_inline, meta.span()));
true
} }
} else { _ => {
self.tcx.emit_spanned_lint( self.tcx.emit_spanned_lint(
INVALID_DOC_ATTRIBUTES, INVALID_DOC_ATTRIBUTES,
hir_id, hir_id,
meta.span(), meta.span(),
errors::DocInlineOnlyUse { errors::DocInlineOnlyUse {
attr_span: meta.span(), attr_span: meta.span(),
item_span: (attr.style == AttrStyle::Outer) item_span: (attr.style == AttrStyle::Outer)
.then(|| self.tcx.hir().span(hir_id)), .then(|| self.tcx.hir().span(hir_id)),
}, },
); );
false false
}
} }
} }
@ -1137,7 +1143,7 @@ impl CheckAttrVisitor<'_> {
errors::DocTestUnknownInclude { errors::DocTestUnknownInclude {
path, path,
value: value.to_string(), value: value.to_string(),
inner: if attr.style == AttrStyle::Inner { "!" } else { "" }, inner: match attr.style { AttrStyle::Inner=> "!" , AttrStyle::Outer => "" },
sugg: (attr.meta().unwrap().span, applicability), sugg: (attr.meta().unwrap().span, applicability),
} }
); );

17
compiler/rustc_resolve/src/build_reduced_graph.rs
View File

@ -298,14 +298,15 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
self.r.record_partial_res(id, PartialRes::new(res)); self.r.record_partial_res(id, PartialRes::new(res));
} }
if module.is_normal() { if module.is_normal() {
if res == Res::Err { match res {
Ok(ty::Visibility::Public) Res::Err => Ok(ty::Visibility::Public),
} else { _ => {
let vis = ty::Visibility::Restricted(res.def_id()); let vis = ty::Visibility::Restricted(res.def_id());
if self.r.is_accessible_from(vis, parent_scope.module) { if self.r.is_accessible_from(vis, parent_scope.module) {
Ok(vis.expect_local()) Ok(vis.expect_local())
} else { } else {
Err(VisResolutionError::AncestorOnly(path.span)) Err(VisResolutionError::AncestorOnly(path.span))
}
} }
} }
} else { } else {

12
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -1552,12 +1552,12 @@ impl<'a> Resolver<'a> {
if b.is_extern_crate() && ident.span.rust_2018() { if b.is_extern_crate() && ident.span.rust_2018() {
help_msgs.push(format!("use `::{ident}` to refer to this {thing} unambiguously")) help_msgs.push(format!("use `::{ident}` to refer to this {thing} unambiguously"))
} }
if misc == AmbiguityErrorMisc::SuggestCrate { match misc {
help_msgs AmbiguityErrorMisc::SuggestCrate => help_msgs
.push(format!("use `crate::{ident}` to refer to this {thing} unambiguously")) .push(format!("use `crate::{ident}` to refer to this {thing} unambiguously")),
} else if misc == AmbiguityErrorMisc::SuggestSelf { AmbiguityErrorMisc::SuggestSelf => help_msgs
help_msgs .push(format!("use `self::{ident}` to refer to this {thing} unambiguously")),
.push(format!("use `self::{ident}` to refer to this {thing} unambiguously")) AmbiguityErrorMisc::FromPrelude | AmbiguityErrorMisc::None => {}
} }
err.span_note(b.span, &note_msg); err.span_note(b.span, &note_msg);

31
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View File

@ -1230,20 +1230,23 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
} }
ty::PredicateKind::WellFormed(ty) => { ty::PredicateKind::WellFormed(ty) => {
if self.tcx.sess.opts.unstable_opts.trait_solver == TraitSolver::Classic { match self.tcx.sess.opts.unstable_opts.trait_solver {
// WF predicates cannot themselves make TraitSolver::Classic => {
// errors. They can only block due to // WF predicates cannot themselves make
// ambiguity; otherwise, they always // errors. They can only block due to
// degenerate into other obligations // ambiguity; otherwise, they always
// (which may fail). // degenerate into other obligations
span_bug!(span, "WF predicate not satisfied for {:?}", ty); // (which may fail).
} else { span_bug!(span, "WF predicate not satisfied for {:?}", ty);
// FIXME: we'll need a better message which takes into account }
// which bounds actually failed to hold. TraitSolver::Chalk | TraitSolver::Next => {
self.tcx.sess.struct_span_err( // FIXME: we'll need a better message which takes into account
span, // which bounds actually failed to hold.
&format!("the type `{}` is not well-formed", ty), self.tcx.sess.struct_span_err(
) span,
&format!("the type `{}` is not well-formed", ty),
)
}
} }
} }