Skip to content

Commit 9583029

Browse files
JohnTitorJohnTitor
authored
Rollup merge of #78002 - estebank:issue-77598, r=oli-obk
Tweak "object unsafe" errors CC #77598.
2 parents ff3c8cb + 88f5e11 commit 9583029

File tree

57 files changed

+754
-475
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

57 files changed

+754
-475
lines changed

‎compiler/rustc_infer/src/traits/error_reporting/mod.rs‎

Lines changed: 23 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,12 @@ use super::ObjectSafetyViolation;
22

33
use crate::infer::InferCtxt;
44
use rustc_data_structures::fx::FxHashSet;
5-
use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
5+
use rustc_errors::{struct_span_err, DiagnosticBuilder};
66
use rustc_hir as hir;
77
use rustc_hir::def_id::DefId;
88
use rustc_middle::ty::TyCtxt;
99
use rustc_span::symbol::Symbol;
10-
use rustc_span::Span;
10+
use rustc_span::{MultiSpan, Span};
1111
use std::fmt;
1212

1313
impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
@@ -54,10 +54,11 @@ pub fn report_object_safety_error(
5454
"the trait `{}` cannot be made into an object",
5555
trait_str
5656
);
57-
err.span_label(span, format!("the trait `{}` cannot be made into an object", trait_str));
57+
err.span_label(span, format!("`{}` cannot be made into an object", trait_str));
5858

5959
let mut reported_violations = FxHashSet::default();
60-
let mut had_span_label = false;
60+
let mut multi_span = vec![];
61+
let mut messages = vec![];
6162
for violation in violations {
6263
if let ObjectSafetyViolation::SizedSelf(sp) = &violation {
6364
if !sp.is_empty() {
@@ -71,31 +72,37 @@ pub fn report_object_safety_error(
7172
let msg = if trait_span.is_none() || spans.is_empty() {
7273
format!("the trait cannot be made into an object because {}", violation.error_msg())
7374
} else {
74-
had_span_label = true;
7575
format!("...because {}", violation.error_msg())
7676
};
7777
if spans.is_empty() {
7878
err.note(&msg);
7979
} else {
8080
for span in spans {
81-
err.span_label(span, &msg);
81+
multi_span.push(span);
82+
messages.push(msg.clone());
8283
}
8384
}
84-
match (trait_span, violation.solution()) {
85-
(Some(_), Some((note, None))) => {
86-
err.help(&note);
87-
}
88-
(Some(_), Some((note, Some((sugg, span))))) => {
89-
err.span_suggestion(span, &note, sugg, Applicability::MachineApplicable);
90-
}
85+
if trait_span.is_some() {
9186
// Only provide the help if its a local trait, otherwise it's not actionable.
92-
_ => {}
87+
violation.solution(&mut err);
9388
}
9489
}
9590
}
96-
if let (Some(trait_span), true) = (trait_span, had_span_label) {
97-
err.span_label(trait_span, "this trait cannot be made into an object...");
91+
let has_multi_span = !multi_span.is_empty();
92+
let mut note_span = MultiSpan::from_spans(multi_span.clone());
93+
if let (Some(trait_span), true) = (trait_span, has_multi_span) {
94+
note_span
95+
.push_span_label(trait_span, "this trait cannot be made into an object...".to_string());
9896
}
97+
for (span, msg) in multi_span.into_iter().zip(messages.into_iter()) {
98+
note_span.push_span_label(span, msg);
99+
}
100+
err.span_note(
101+
note_span,
102+
"for a trait to be \"object safe\" it needs to allow building a vtable to allow the call \
103+
to be resolvable dynamically; for more information visit \
104+
<https://doc.rust-lang.org/reference/items/traits.html#object-safety>",
105+
);
99106

100107
if tcx.sess.trait_methods_not_found.borrow().contains(&span) {
101108
// Avoid emitting error caused by non-existing method (#58734)

‎compiler/rustc_middle/src/traits/mod.rs‎

Lines changed: 55 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use crate::mir::interpret::ErrorHandled;
1313
use crate::ty::subst::SubstsRef;
1414
use crate::ty::{self, AdtKind, Ty, TyCtxt};
1515

16+
use rustc_errors::{Applicability, DiagnosticBuilder};
1617
use rustc_hir as hir;
1718
use rustc_hir::def_id::DefId;
1819
use rustc_span::symbol::Symbol;
@@ -646,13 +647,13 @@ impl ObjectSafetyViolation {
646647
ObjectSafetyViolation::SizedSelf(_) => "it requires `Self: Sized`".into(),
647648
ObjectSafetyViolation::SupertraitSelf(ref spans) => {
648649
if spans.iter().any(|sp| *sp != DUMMY_SP) {
649-
"it uses `Self` as a type parameter in this".into()
650+
"it uses `Self` as a type parameter".into()
650651
} else {
651652
"it cannot use `Self` as a type parameter in a supertrait or `where`-clause"
652653
.into()
653654
}
654655
}
655-
ObjectSafetyViolation::Method(name, MethodViolationCode::StaticMethod(_), _) => {
656+
ObjectSafetyViolation::Method(name, MethodViolationCode::StaticMethod(_, _, _), _) => {
656657
format!("associated function `{}` has no `self` parameter", name).into()
657658
}
658659
ObjectSafetyViolation::Method(
@@ -686,32 +687,65 @@ impl ObjectSafetyViolation {
686687
}
687688
}
688689

689-
pub fn solution(&self) -> Option<(String, Option<(String, Span)>)> {
690-
Some(match *self {
691-
ObjectSafetyViolation::SizedSelf(_) | ObjectSafetyViolation::SupertraitSelf(_) => {
692-
return None;
690+
pub fn solution(&self, err: &mut DiagnosticBuilder<'_>) {
691+
match *self {
692+
ObjectSafetyViolation::SizedSelf(_) | ObjectSafetyViolation::SupertraitSelf(_) => {}
693+
ObjectSafetyViolation::Method(
694+
name,
695+
MethodViolationCode::StaticMethod(sugg, self_span, has_args),
696+
_,
697+
) => {
698+
err.span_suggestion(
699+
self_span,
700+
&format!(
701+
"consider turning `{}` into a method by giving it a `&self` argument",
702+
name
703+
),
704+
format!("&self{}", if has_args { ", " } else { "" }),
705+
Applicability::MaybeIncorrect,
706+
);
707+
match sugg {
708+
Some((sugg, span)) => {
709+
err.span_suggestion(
710+
span,
711+
&format!(
712+
"alternatively, consider constraining `{}` so it does not apply to \
713+
trait objects",
714+
name
715+
),
716+
sugg.to_string(),
717+
Applicability::MaybeIncorrect,
718+
);
719+
}
720+
None => {
721+
err.help(&format!(
722+
"consider turning `{}` into a method by giving it a `&self` \
723+
argument or constraining it so it does not apply to trait objects",
724+
name
725+
));
726+
}
727+
}
693728
}
694-
ObjectSafetyViolation::Method(name, MethodViolationCode::StaticMethod(sugg), _) => (
695-
format!(
696-
"consider turning `{}` into a method by giving it a `&self` argument or \
697-
constraining it so it does not apply to trait objects",
698-
name
699-
),
700-
sugg.map(|(sugg, sp)| (sugg.to_string(), sp)),
701-
),
702729
ObjectSafetyViolation::Method(
703730
name,
704731
MethodViolationCode::UndispatchableReceiver,
705732
span,
706-
) => (
707-
format!("consider changing method `{}`'s `self` parameter to be `&self`", name),
708-
Some(("&Self".to_string(), span)),
709-
),
733+
) => {
734+
err.span_suggestion(
735+
span,
736+
&format!(
737+
"consider changing method `{}`'s `self` parameter to be `&self`",
738+
name
739+
),
740+
"&Self".to_string(),
741+
Applicability::MachineApplicable,
742+
);
743+
}
710744
ObjectSafetyViolation::AssocConst(name, _)
711745
| ObjectSafetyViolation::Method(name, ..) => {
712-
(format!("consider moving `{}` to another trait", name), None)
746+
err.help(&format!("consider moving `{}` to another trait", name));
713747
}
714-
})
748+
}
715749
}
716750

717751
pub fn spans(&self) -> SmallVec<[Span; 1]> {
@@ -735,7 +769,7 @@ impl ObjectSafetyViolation {
735769
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
736770
pub enum MethodViolationCode {
737771
/// e.g., `fn foo()`
738-
StaticMethod(Option<(&'static str, Span)>),
772+
StaticMethod(Option<(&'static str, Span)>, Span, bool /* has args */),
739773

740774
/// e.g., `fn foo(&self, x: Self)`
741775
ReferencesSelfInput(usize),

‎compiler/rustc_trait_selection/src/traits/object_safety.rs‎

Lines changed: 63 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -13,15 +13,15 @@ use super::elaborate_predicates;
1313
use crate::infer::TyCtxtInferExt;
1414
use crate::traits::query::evaluate_obligation::InferCtxtExt;
1515
use crate::traits::{self, Obligation, ObligationCause};
16-
use rustc_errors::{Applicability, FatalError};
16+
use rustc_errors::FatalError;
1717
use rustc_hir as hir;
1818
use rustc_hir::def_id::DefId;
1919
use rustc_middle::ty::subst::{GenericArg, InternalSubsts, Subst};
2020
use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeVisitor, WithConstness};
2121
use rustc_middle::ty::{Predicate, ToPredicate};
2222
use rustc_session::lint::builtin::WHERE_CLAUSES_OBJECT_SAFETY;
2323
use rustc_span::symbol::Symbol;
24-
use rustc_span::Span;
24+
use rustc_span::{MultiSpan, Span};
2525
use smallvec::SmallVec;
2626

2727
use std::array;
@@ -100,49 +100,7 @@ fn object_safety_violations_for_trait(
100100
span,
101101
) = violation
102102
{
103-
// Using `CRATE_NODE_ID` is wrong, but it's hard to get a more precise id.
104-
// It's also hard to get a use site span, so we use the method definition span.
105-
tcx.struct_span_lint_hir(
106-
WHERE_CLAUSES_OBJECT_SAFETY,
107-
hir::CRATE_HIR_ID,
108-
*span,
109-
|lint| {
110-
let mut err = lint.build(&format!(
111-
"the trait `{}` cannot be made into an object",
112-
tcx.def_path_str(trait_def_id)
113-
));
114-
let node = tcx.hir().get_if_local(trait_def_id);
115-
let msg = if let Some(hir::Node::Item(item)) = node {
116-
err.span_label(
117-
item.ident.span,
118-
"this trait cannot be made into an object...",
119-
);
120-
format!("...because {}", violation.error_msg())
121-
} else {
122-
format!(
123-
"the trait cannot be made into an object because {}",
124-
violation.error_msg()
125-
)
126-
};
127-
err.span_label(*span, &msg);
128-
match (node, violation.solution()) {
129-
(Some(_), Some((note, None))) => {
130-
err.help(&note);
131-
}
132-
(Some(_), Some((note, Some((sugg, span))))) => {
133-
err.span_suggestion(
134-
span,
135-
&note,
136-
sugg,
137-
Applicability::MachineApplicable,
138-
);
139-
}
140-
// Only provide the help if its a local trait, otherwise it's not actionable.
141-
_ => {}
142-
}
143-
err.emit();
144-
},
145-
);
103+
lint_object_unsafe_trait(tcx, *span, trait_def_id, violation);
146104
false
147105
} else {
148106
true
@@ -180,6 +138,51 @@ fn object_safety_violations_for_trait(
180138
violations
181139
}
182140

141+
/// Lint object-unsafe trait.
142+
fn lint_object_unsafe_trait(
143+
tcx: TyCtxt<'_>,
144+
span: Span,
145+
trait_def_id: DefId,
146+
violation: &ObjectSafetyViolation,
147+
) {
148+
// Using `CRATE_NODE_ID` is wrong, but it's hard to get a more precise id.
149+
// It's also hard to get a use site span, so we use the method definition span.
150+
tcx.struct_span_lint_hir(WHERE_CLAUSES_OBJECT_SAFETY, hir::CRATE_HIR_ID, span, |lint| {
151+
let mut err = lint.build(&format!(
152+
"the trait `{}` cannot be made into an object",
153+
tcx.def_path_str(trait_def_id)
154+
));
155+
let node = tcx.hir().get_if_local(trait_def_id);
156+
let mut spans = MultiSpan::from_span(span);
157+
if let Some(hir::Node::Item(item)) = node {
158+
spans.push_span_label(
159+
item.ident.span,
160+
"this trait cannot be made into an object...".into(),
161+
);
162+
spans.push_span_label(span, format!("...because {}", violation.error_msg()));
163+
} else {
164+
spans.push_span_label(
165+
span,
166+
format!(
167+
"the trait cannot be made into an object because {}",
168+
violation.error_msg()
169+
),
170+
);
171+
};
172+
err.span_note(
173+
spans,
174+
"for a trait to be \"object safe\" it needs to allow building a vtable to allow the \
175+
call to be resolvable dynamically; for more information visit \
176+
<https://doc.rust-lang.org/reference/items/traits.html#object-safety>",
177+
);
178+
if node.is_some() {
179+
// Only provide the help if its a local trait, otherwise it's not
180+
violation.solution(&mut err);
181+
}
182+
err.emit();
183+
});
184+
}
185+
183186
fn sized_trait_bound_spans<'tcx>(
184187
tcx: TyCtxt<'tcx>,
185188
bounds: hir::GenericBounds<'tcx>,
@@ -385,6 +388,8 @@ fn virtual_call_violation_for_method<'tcx>(
385388
trait_def_id: DefId,
386389
method: &ty::AssocItem,
387390
) -> Option<MethodViolationCode> {
391+
let sig = tcx.fn_sig(method.def_id);
392+
388393
// The method's first parameter must be named `self`
389394
if !method.fn_has_self_parameter {
390395
// We'll attempt to provide a structured suggestion for `Self: Sized`.
@@ -395,11 +400,21 @@ fn virtual_call_violation_for_method<'tcx>(
395400
[.., pred] => (", Self: Sized", pred.span().shrink_to_hi()),
396401
},
397402
);
398-
return Some(MethodViolationCode::StaticMethod(sugg));
403+
// Get the span pointing at where the `self` receiver should be.
404+
let sm = tcx.sess.source_map();
405+
let self_span = method.ident.span.to(tcx
406+
.hir()
407+
.span_if_local(method.def_id)
408+
.unwrap_or_else(|| sm.next_point(method.ident.span))
409+
.shrink_to_hi());
410+
let self_span = sm.span_through_char(self_span, '(').shrink_to_hi();
411+
return Some(MethodViolationCode::StaticMethod(
412+
sugg,
413+
self_span,
414+
!sig.inputs().skip_binder().is_empty(),
415+
));
399416
}
400417

401-
let sig = tcx.fn_sig(method.def_id);
402-
403418
for (i, input_ty) in sig.skip_binder().inputs()[1..].iter().enumerate() {
404419
if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) {
405420
return Some(MethodViolationCode::ReferencesSelfInput(i));

‎src/test/ui/associated-consts/associated-const-in-trait.stderr‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,17 @@
11
error[E0038]: the trait `Trait` cannot be made into an object
22
--> $DIR/associated-const-in-trait.rs:9:6
33
|
4-
LL | trait Trait {
5-
| ----- this trait cannot be made into an object...
6-
LL | const N: usize;
7-
| - ...because it contains this associated `const`
8-
...
94
LL | impl dyn Trait {
10-
| ^^^^^^^^^ the trait `Trait` cannot be made into an object
5+
| ^^^^^^^^^ `Trait` cannot be made into an object
116
|
127
= help: consider moving `N` to another trait
8+
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
9+
--> $DIR/associated-const-in-trait.rs:6:11
10+
|
11+
LL | trait Trait {
12+
| ----- this trait cannot be made into an object...
13+
LL | const N: usize;
14+
| ^ ...because it contains this associated `const`
1315

1416
error: aborting due to previous error
1517

‎src/test/ui/associated-item/issue-48027.stderr‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,17 @@
11
error[E0038]: the trait `Bar` cannot be made into an object
22
--> $DIR/issue-48027.rs:6:6
33
|
4-
LL | trait Bar {
5-
| --- this trait cannot be made into an object...
6-
LL | const X: usize;
7-
| - ...because it contains this associated `const`
8-
...
94
LL | impl dyn Bar {}
10-
| ^^^^^^^ the trait `Bar` cannot be made into an object
5+
| ^^^^^^^ `Bar` cannot be made into an object
116
|
127
= help: consider moving `X` to another trait
8+
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
9+
--> $DIR/issue-48027.rs:2:11
10+
|
11+
LL | trait Bar {
12+
| --- this trait cannot be made into an object...
13+
LL | const X: usize;
14+
| ^ ...because it contains this associated `const`
1315

1416
error[E0283]: type annotations needed
1517
--> $DIR/issue-48027.rs:3:32

0 commit comments

Comments
 (0)