Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 800221b

Browse files
matthiaskrgrmatthiaskrgr
authoredFeb 6, 2023
Rollup merge of #106477 - Nathan-Fenner:nathanf/refined-error-span-trait-impl, r=compiler-errors
Refine error spans for "The trait bound `T: Trait` is not satisfied" when passing literal structs/tuples This PR adds a new heuristic which refines the error span reported for "`T: Trait` is not satisfied" errors, by "drilling down" into individual fields of structs/enums/tuples to point to the "problematic" value. Here's a self-contained example of the difference in error span: ```rs struct Burrito<Filling> { filling: Filling, } impl <Filling: Delicious> Delicious for Burrito<Filling> {} fn eat_delicious_food<Food: Delicious>(food: Food) {} fn will_type_error() { eat_delicious_food(Burrito { filling: Kale }); // ^~~~~~~~~~~~~~~~~~~~~~~~~ (before) The trait bound `Kale: Delicious` is not satisfied // ^~~~ (after) The trait bound `Kale: Delicious` is not satisfied } ``` (kale is fine, this is just a silly food-based example) Before this PR, the error span is identified as the entire argument to the generic function `eat_delicious_food`. However, since only `Kale` is the "problematic" part, we can point at it specifically. In particular, the primary error message itself mentions the missing `Kale: Delicious` trait bound, so it's much clearer if this part is called out explicitly. --- The _existing_ heuristic tries to label the right function argument in `point_at_arg_if_possible`. It goes something like this: - Look at the broken base trait `Food: Delicious` and find which generics it mentions (in this case, only `Food`) - Look at the parameter type definitions and find which of them mention `Filling` (in this case, only `food`) - If there is exactly one relevant parameter, label the corresponding argument with the error span, instead of the entire call This PR extends this heuristic by further refining the resulting expression span in the new `point_at_specific_expr_if_possible` function. For each `impl` in the (broken) chain, we apply the following strategy: The strategy to determine this span involves connecting information about our generic `impl` with information about our (struct) type and the (struct) literal expression: - Find the `impl` (`impl <Filling: Delicious> Delicious for Burrito<Filling>`) that links our obligation (`Kale: Delicious`) with the parent obligation (`Burrito<Kale>: Delicious`) - Find the "original" predicate constraint in the impl (`Filling: Delicious`) which produced our obligation. - Find all of the generics that are mentioned in the predicate (`Filling`). - Examine the `Self` type in the `impl`, and see which of its type argument(s) mention any of those generics. - Examing the definition for the `Self` type, and identify (for each of its variants) if there's a unique field which uses those generic arguments. - If there is a unique field mentioning the "blameable" arguments, use that field for the error span. Before we do any of this logic, we recursively call `point_at_specific_expr_if_possible` on the parent obligation. Hence we refine the `expr` "outwards-in" and bail at the first kind of expression/impl we don't recognize. This function returns a `Result<&Expr, &Expr>` - either way, it returns the `Expr` whose span should be reported as an error. If it is `Ok`, then it means it refined successfull. If it is `Err`, then it may be only a partial success - but it cannot be refined even further. --- I added a new test file which exercises this new behavior. A few existing tests were affected, since their error spans are now different. In one case, this leads to a different code suggestion for the autofix - although the new suggestion isn't _wrong_, it is different from what used to be. This change doesn't create any new errors or remove any existing ones, it just adjusts the spans where they're presented. --- Some considerations: right now, this check occurs in addition to some similar logic in `adjust_fulfillment_error_for_expr_obligation` function, which tidies up various kinds of error spans (not just trait-fulfillment error). It's possible that this new code would be better integrated into that function (or another one) - but I haven't looked into this yet. Although this code only occurs when there's a type error, it's definitely not as efficient as possible. In particular, there are definitely some cases where it degrades to quadratic performance (e.g. for a trait `impl` with 100+ generic parameters or 100 levels deep nesting of generic types). I'm not sure if these are realistic enough to worry about optimizing yet. There's also still a lot of repetition in some of the logic, where the behavior for different types (namely, `struct` vs `enum` variant) is _similar_ but not the same. --- I think the biggest win here is better targeting for tuples; in particular, if you're using tuples + traits to express variadic-like functions, the compiler can't tell you which part of a tuple has the wrong type, since the span will cover the entire argument. This change allows the individual field in the tuple to be highlighted, as in this example: ``` // NEW LL | want(Wrapper { value: (3, q) }); | ---- ^ the trait `T3` is not implemented for `Q` // OLD LL | want(Wrapper { value: (3, q) }); | ---- ^~~~~~~~~~~~~~~~~~~~~~~~~ the trait `T3` is not implemented for `Q` ``` Especially with large tuples, the existing error spans are not very effective at quickly narrowing down the source of the problem.
2 parents 7ff69b4 + 99638a6 commit 800221b

File tree

14 files changed

+1120
-81
lines changed

14 files changed

+1120
-81
lines changed
 

‎compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs

Lines changed: 457 additions & 0 deletions
Large diffs are not rendered by default.

‎compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

Lines changed: 42 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,10 @@ use rustc_trait_selection::traits::{self, ObligationCauseCode, SelectionContext}
3434

3535
use std::iter;
3636
use std::mem;
37-
use std::ops::ControlFlow;
3837
use std::slice;
3938

39+
use std::ops::ControlFlow;
40+
4041
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
4142
pub(in super::super) fn check_casts(&mut self) {
4243
// don't hold the borrow to deferred_cast_checks while checking to avoid borrow checker errors
@@ -1843,7 +1844,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
18431844
.into_iter()
18441845
.flatten()
18451846
{
1846-
if self.point_at_arg_if_possible(
1847+
if self.blame_specific_arg_if_possible(
18471848
error,
18481849
def_id,
18491850
param,
@@ -1873,7 +1874,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
18731874
.into_iter()
18741875
.flatten()
18751876
{
1876-
if self.point_at_arg_if_possible(
1877+
if self.blame_specific_arg_if_possible(
18771878
error,
18781879
def_id,
18791880
param,
@@ -1898,16 +1899,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
18981899
for param in
18991900
[param_to_point_at, fallback_param_to_point_at, self_param_to_point_at]
19001901
{
1901-
if let Some(param) = param
1902-
&& self.point_at_field_if_possible(
1903-
error,
1902+
if let Some(param) = param {
1903+
let refined_expr = self.point_at_field_if_possible(
19041904
def_id,
19051905
param,
19061906
variant_def_id,
19071907
fields,
1908-
)
1909-
{
1910-
return true;
1908+
);
1909+
1910+
match refined_expr {
1911+
None => {}
1912+
Some((refined_expr, _)) => {
1913+
error.obligation.cause.span = refined_expr
1914+
.span
1915+
.find_ancestor_in_same_ctxt(error.obligation.cause.span)
1916+
.unwrap_or(refined_expr.span);
1917+
return true;
1918+
}
1919+
}
19111920
}
19121921
}
19131922
}
@@ -1940,7 +1949,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
19401949
}
19411950
}
19421951

1943-
fn point_at_arg_if_possible(
1952+
/// - `blame_specific_*` means that the function will recursively traverse the expression,
1953+
/// looking for the most-specific-possible span to blame.
1954+
///
1955+
/// - `point_at_*` means that the function will only go "one level", pointing at the specific
1956+
/// expression mentioned.
1957+
///
1958+
/// `blame_specific_arg_if_possible` will find the most-specific expression anywhere inside
1959+
/// the provided function call expression, and mark it as responsible for the fullfillment
1960+
/// error.
1961+
fn blame_specific_arg_if_possible(
19441962
&self,
19451963
error: &mut traits::FulfillmentError<'tcx>,
19461964
def_id: DefId,
@@ -1959,13 +1977,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
19591977
.inputs()
19601978
.iter()
19611979
.enumerate()
1962-
.filter(|(_, ty)| find_param_in_ty(**ty, param_to_point_at))
1980+
.filter(|(_, ty)| Self::find_param_in_ty((**ty).into(), param_to_point_at))
19631981
.collect();
19641982
// If there's one field that references the given generic, great!
19651983
if let [(idx, _)] = args_referencing_param.as_slice()
19661984
&& let Some(arg) = receiver
19671985
.map_or(args.get(*idx), |rcvr| if *idx == 0 { Some(rcvr) } else { args.get(*idx - 1) }) {
1986+
19681987
error.obligation.cause.span = arg.span.find_ancestor_in_same_ctxt(error.obligation.cause.span).unwrap_or(arg.span);
1988+
1989+
if let hir::Node::Expr(arg_expr) = self.tcx.hir().get(arg.hir_id) {
1990+
// This is more specific than pointing at the entire argument.
1991+
self.blame_specific_expr_if_possible(error, arg_expr)
1992+
}
1993+
19691994
error.obligation.cause.map_code(|parent_code| {
19701995
ObligationCauseCode::FunctionArgumentObligation {
19711996
arg_hir_id: arg.hir_id,
@@ -1983,14 +2008,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
19832008
false
19842009
}
19852010

1986-
fn point_at_field_if_possible(
2011+
// FIXME: Make this private and move to mod adjust_fulfillment_errors
2012+
pub fn point_at_field_if_possible(
19872013
&self,
1988-
error: &mut traits::FulfillmentError<'tcx>,
19892014
def_id: DefId,
19902015
param_to_point_at: ty::GenericArg<'tcx>,
19912016
variant_def_id: DefId,
19922017
expr_fields: &[hir::ExprField<'tcx>],
1993-
) -> bool {
2018+
) -> Option<(&'tcx hir::Expr<'tcx>, Ty<'tcx>)> {
19942019
let def = self.tcx.adt_def(def_id);
19952020

19962021
let identity_substs = ty::InternalSubsts::identity_for_item(self.tcx, def_id);
@@ -2000,7 +2025,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
20002025
.iter()
20012026
.filter(|field| {
20022027
let field_ty = field.ty(self.tcx, identity_substs);
2003-
find_param_in_ty(field_ty, param_to_point_at)
2028+
Self::find_param_in_ty(field_ty.into(), param_to_point_at)
20042029
})
20052030
.collect();
20062031

@@ -2010,17 +2035,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
20102035
// same rules that check_expr_struct uses for macro hygiene.
20112036
if self.tcx.adjust_ident(expr_field.ident, variant_def_id) == field.ident(self.tcx)
20122037
{
2013-
error.obligation.cause.span = expr_field
2014-
.expr
2015-
.span
2016-
.find_ancestor_in_same_ctxt(error.obligation.cause.span)
2017-
.unwrap_or(expr_field.span);
2018-
return true;
2038+
return Some((expr_field.expr, self.tcx.type_of(field.did)));
20192039
}
20202040
}
20212041
}
20222042

2023-
false
2043+
None
20242044
}
20252045

20262046
fn point_at_path_if_possible(
@@ -2240,23 +2260,3 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
22402260
}
22412261
}
22422262
}
2243-
2244-
fn find_param_in_ty<'tcx>(ty: Ty<'tcx>, param_to_point_at: ty::GenericArg<'tcx>) -> bool {
2245-
let mut walk = ty.walk();
2246-
while let Some(arg) = walk.next() {
2247-
if arg == param_to_point_at {
2248-
return true;
2249-
} else if let ty::GenericArgKind::Type(ty) = arg.unpack()
2250-
&& let ty::Alias(ty::Projection, ..) = ty.kind()
2251-
{
2252-
// This logic may seem a bit strange, but typically when
2253-
// we have a projection type in a function signature, the
2254-
// argument that's being passed into that signature is
2255-
// not actually constraining that projection's substs in
2256-
// a meaningful way. So we skip it, and see improvements
2257-
// in some UI tests.
2258-
walk.skip_current_subtree();
2259-
}
2260-
}
2261-
false
2262-
}

‎compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
mod _impl;
2+
mod adjust_fulfillment_errors;
23
mod arg_matrix;
34
mod checks;
45
mod suggestions;

‎compiler/rustc_hir_typeck/src/method/probe.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1563,6 +1563,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
15631563
traits::ImplDerivedObligationCause {
15641564
derived,
15651565
impl_def_id,
1566+
impl_def_predicate_index: None,
15661567
span,
15671568
},
15681569
))

‎compiler/rustc_infer/src/traits/util.rs

Lines changed: 26 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -145,30 +145,32 @@ impl<'tcx> Elaborator<'tcx> {
145145
// Get predicates declared on the trait.
146146
let predicates = tcx.super_predicates_of(data.def_id());
147147

148-
let obligations = predicates.predicates.iter().map(|&(mut pred, span)| {
149-
// when parent predicate is non-const, elaborate it to non-const predicates.
150-
if data.constness == ty::BoundConstness::NotConst {
151-
pred = pred.without_const(tcx);
152-
}
153-
154-
let cause = obligation.cause.clone().derived_cause(
155-
bound_predicate.rebind(data),
156-
|derived| {
157-
traits::ImplDerivedObligation(Box::new(
158-
traits::ImplDerivedObligationCause {
159-
derived,
160-
impl_def_id: data.def_id(),
161-
span,
162-
},
163-
))
164-
},
165-
);
166-
predicate_obligation(
167-
pred.subst_supertrait(tcx, &bound_predicate.rebind(data.trait_ref)),
168-
obligation.param_env,
169-
cause,
170-
)
171-
});
148+
let obligations =
149+
predicates.predicates.iter().enumerate().map(|(index, &(mut pred, span))| {
150+
// when parent predicate is non-const, elaborate it to non-const predicates.
151+
if data.constness == ty::BoundConstness::NotConst {
152+
pred = pred.without_const(tcx);
153+
}
154+
155+
let cause = obligation.cause.clone().derived_cause(
156+
bound_predicate.rebind(data),
157+
|derived| {
158+
traits::ImplDerivedObligation(Box::new(
159+
traits::ImplDerivedObligationCause {
160+
derived,
161+
impl_def_id: data.def_id(),
162+
impl_def_predicate_index: Some(index),
163+
span,
164+
},
165+
))
166+
},
167+
);
168+
predicate_obligation(
169+
pred.subst_supertrait(tcx, &bound_predicate.rebind(data.trait_ref)),
170+
obligation.param_env,
171+
cause,
172+
)
173+
});
172174
debug!(?data, ?obligations, "super_predicates");
173175

174176
// Only keep those bounds that we haven't already seen.

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

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -475,6 +475,8 @@ pub enum WellFormedLoc {
475475
pub struct ImplDerivedObligationCause<'tcx> {
476476
pub derived: DerivedObligationCause<'tcx>,
477477
pub impl_def_id: DefId,
478+
/// The index of the derived predicate in the parent impl's predicates.
479+
pub impl_def_predicate_index: Option<usize>,
478480
pub span: Span,
479481
}
480482

‎compiler/rustc_trait_selection/src/traits/select/confirmation.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1190,6 +1190,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
11901190
ImplDerivedObligation(Box::new(ImplDerivedObligationCause {
11911191
derived,
11921192
impl_def_id,
1193+
impl_def_predicate_index: None,
11931194
span: obligation.cause.span,
11941195
}))
11951196
});

‎compiler/rustc_trait_selection/src/traits/select/mod.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2608,11 +2608,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
26082608
assert_eq!(predicates.parent, None);
26092609
let predicates = predicates.instantiate_own(tcx, substs);
26102610
let mut obligations = Vec::with_capacity(predicates.len());
2611-
for (predicate, span) in predicates {
2611+
for (index, (predicate, span)) in predicates.into_iter().enumerate() {
26122612
let cause = cause.clone().derived_cause(parent_trait_pred, |derived| {
26132613
ImplDerivedObligation(Box::new(ImplDerivedObligationCause {
26142614
derived,
26152615
impl_def_id: def_id,
2616+
impl_def_predicate_index: Some(index),
26162617
span,
26172618
}))
26182619
});

‎tests/ui/derives/deriving-copyclone.stderr

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
error[E0277]: the trait bound `B<C>: Copy` is not satisfied
2-
--> $DIR/deriving-copyclone.rs:31:13
2+
--> $DIR/deriving-copyclone.rs:31:26
33
|
44
LL | is_copy(B { a: 1, b: C });
5-
| ------- ^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `B<C>`
5+
| ------- ^ the trait `Copy` is not implemented for `B<C>`
66
| |
77
| required by a bound introduced by this call
88
|
@@ -19,14 +19,14 @@ LL | fn is_copy<T: Copy>(_: T) {}
1919
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
2020
help: consider borrowing here
2121
|
22-
LL | is_copy(&B { a: 1, b: C });
23-
| +
22+
LL | is_copy(B { a: 1, b: &C });
23+
| +
2424

2525
error[E0277]: the trait bound `B<C>: Clone` is not satisfied
26-
--> $DIR/deriving-copyclone.rs:32:14
26+
--> $DIR/deriving-copyclone.rs:32:27
2727
|
2828
LL | is_clone(B { a: 1, b: C });
29-
| -------- ^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `B<C>`
29+
| -------- ^ the trait `Clone` is not implemented for `B<C>`
3030
| |
3131
| required by a bound introduced by this call
3232
|
@@ -43,14 +43,14 @@ LL | fn is_clone<T: Clone>(_: T) {}
4343
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
4444
help: consider borrowing here
4545
|
46-
LL | is_clone(&B { a: 1, b: C });
47-
| +
46+
LL | is_clone(B { a: 1, b: &C });
47+
| +
4848

4949
error[E0277]: the trait bound `B<D>: Copy` is not satisfied
50-
--> $DIR/deriving-copyclone.rs:35:13
50+
--> $DIR/deriving-copyclone.rs:35:26
5151
|
5252
LL | is_copy(B { a: 1, b: D });
53-
| ------- ^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `B<D>`
53+
| ------- ^ the trait `Copy` is not implemented for `B<D>`
5454
| |
5555
| required by a bound introduced by this call
5656
|
@@ -67,8 +67,8 @@ LL | fn is_copy<T: Copy>(_: T) {}
6767
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
6868
help: consider borrowing here
6969
|
70-
LL | is_copy(&B { a: 1, b: D });
71-
| +
70+
LL | is_copy(B { a: 1, b: &D });
71+
| +
7272

7373
error: aborting due to 3 previous errors
7474

‎tests/ui/errors/trait-bound-error-spans/blame-trait-error.rs

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
trait T1 {}
2+
trait T2 {}
3+
trait T3 {}
4+
trait T4 {}
5+
6+
impl<B: T2> T1 for Wrapper<B> {}
7+
8+
impl T2 for i32 {}
9+
impl T3 for i32 {}
10+
11+
impl<A: T3> T2 for Burrito<A> {}
12+
13+
struct Wrapper<W> {
14+
value: W,
15+
}
16+
17+
struct Burrito<F> {
18+
filling: F,
19+
}
20+
21+
fn want<V: T1>(_x: V) {}
22+
23+
fn example<Q>(q: Q) {
24+
want(Wrapper { value: Burrito { filling: q } });
25+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
26+
}
27+
28+
fn main() {}

‎tests/ui/errors/trait-bound-error-spans/blame-trait-error.stderr

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
error[E0277]: the trait bound `Q: T3` is not satisfied
2+
--> $DIR/blame-trait-error.rs:24:46
3+
|
4+
LL | want(Wrapper { value: Burrito { filling: q } });
5+
| ---- ^ the trait `T3` is not implemented for `Q`
6+
| |
7+
| required by a bound introduced by this call
8+
|
9+
note: required for `Burrito<Q>` to implement `T2`
10+
--> $DIR/blame-trait-error.rs:11:13
11+
|
12+
LL | impl<A: T3> T2 for Burrito<A> {}
13+
| -- ^^ ^^^^^^^^^^
14+
| |
15+
| unsatisfied trait bound introduced here
16+
note: required for `Wrapper<Burrito<Q>>` to implement `T1`
17+
--> $DIR/blame-trait-error.rs:6:13
18+
|
19+
LL | impl<B: T2> T1 for Wrapper<B> {}
20+
| -- ^^ ^^^^^^^^^^
21+
| |
22+
| unsatisfied trait bound introduced here
23+
note: required by a bound in `want`
24+
--> $DIR/blame-trait-error.rs:21:12
25+
|
26+
LL | fn want<V: T1>(_x: V) {}
27+
| ^^ required by this bound in `want`
28+
help: consider restricting type parameter `Q`
29+
|
30+
LL | fn example<Q: T3>(q: Q) {
31+
| ++++
32+
33+
error: aborting due to previous error
34+
35+
For more information about this error, try `rustc --explain E0277`.

‎tests/ui/errors/traits/blame-trait-error-spans-on-exprs.rs

Lines changed: 131 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,131 @@
1+
// This test examines the error spans reported when a generic `impl` fails.
2+
// For example, if a function wants an `Option<T>` where `T: Copy` but you pass `Some(vec![1, 2])`,
3+
// then we want to point at the `vec![1, 2]` and not the `Some( ... )` expression.
4+
5+
trait T1 {}
6+
trait T2 {}
7+
trait T3 {}
8+
trait T4 {}
9+
10+
impl T2 for i32 {}
11+
impl T3 for i32 {}
12+
13+
struct Wrapper<W> {
14+
value: W,
15+
}
16+
impl<B: T2> T1 for Wrapper<B> {}
17+
18+
struct Burrito<F> {
19+
spicy: bool,
20+
filling: F,
21+
}
22+
impl<A: T3> T2 for Burrito<A> {}
23+
24+
struct BurritoTuple<F>(F);
25+
impl<C: T3> T2 for BurritoTuple<C> {}
26+
27+
enum BurritoKinds<G> {
28+
SmallBurrito { spicy: bool, small_filling: G },
29+
LargeBurrito { spicy: bool, large_filling: G },
30+
MultiBurrito { first_filling: G, second_filling: G },
31+
}
32+
impl<D: T3> T2 for BurritoKinds<D> {}
33+
34+
struct Taco<H>(bool, H);
35+
impl<E: T3> T2 for Taco<E> {}
36+
37+
enum TacoKinds<H> {
38+
OneTaco(bool, H),
39+
TwoTacos(bool, H, H),
40+
}
41+
impl<F: T3> T2 for TacoKinds<F> {}
42+
43+
struct GenericBurrito<Spiciness, Filling> {
44+
spiciness: Spiciness,
45+
filling: Filling,
46+
}
47+
impl<X, Y: T3> T2 for GenericBurrito<X, Y> {}
48+
struct NotSpicy;
49+
50+
impl<A: T3, B: T3> T2 for (A, B) {}
51+
impl<A: T2, B: T2> T1 for (A, B) {}
52+
53+
fn want<V: T1>(_x: V) {}
54+
55+
// Some more-complex examples:
56+
type AliasBurrito<T> = GenericBurrito<T, T>;
57+
58+
// The following example is fairly confusing. The idea is that we want to "misdirect" the location
59+
// of the error.
60+
61+
struct Two<A, B> {
62+
a: A,
63+
b: B,
64+
}
65+
66+
impl<X, Y: T1, Z> T1 for Two<Two<X, Y>, Z> {}
67+
68+
struct DoubleWrapper<T> {
69+
item: Wrapper<T>,
70+
}
71+
72+
impl<T: T1> T1 for DoubleWrapper<T> {}
73+
74+
fn example<Q>(q: Q) {
75+
// In each of the following examples, we expect the error span to point at the 'q' variable,
76+
// since the missing constraint is `Q: T3`.
77+
78+
// Verifies for struct:
79+
want(Wrapper { value: Burrito { spicy: false, filling: q } });
80+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
81+
82+
// Verifies for enum with named fields in variant:
83+
want(Wrapper { value: BurritoKinds::SmallBurrito { spicy: true, small_filling: q } });
84+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
85+
86+
// Verifies for tuple struct:
87+
want(Wrapper { value: Taco(false, q) });
88+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
89+
90+
// Verifies for tuple enum variant:
91+
want(Wrapper { value: TacoKinds::OneTaco(false, q) });
92+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
93+
94+
// Verifies for generic type with multiple parameters:
95+
want(Wrapper { value: GenericBurrito { spiciness: NotSpicy, filling: q } });
96+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
97+
98+
// Verifies for tuple:
99+
want((3, q));
100+
//~^ ERROR the trait bound `Q: T2` is not satisfied [E0277]
101+
102+
// Verifies for nested tuple:
103+
want(Wrapper { value: (3, q) });
104+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
105+
106+
// Verifies for nested tuple:
107+
want(((3, q), 5));
108+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
109+
110+
want(DoubleWrapper { item: Wrapper { value: q } });
111+
//~^ ERROR the trait bound `Q: T1` is not satisfied [E0277]
112+
113+
want(DoubleWrapper { item: Wrapper { value: DoubleWrapper { item: Wrapper { value: q } } } });
114+
//~^ ERROR the trait bound `Q: T1` is not satisfied [E0277]
115+
116+
// Verifies for type alias to struct:
117+
want(Wrapper { value: AliasBurrito { spiciness: q, filling: q } });
118+
//~^ ERROR the trait bound `Q: T3` is not satisfied [E0277]
119+
120+
want(Two { a: Two { a: (), b: q }, b: () });
121+
//~^ ERROR the trait bound `Q: T1` is not satisfied [E0277]
122+
123+
// We *should* blame the 'q'.
124+
// FIXME: Right now, the wrong field is blamed.
125+
want(
126+
Two { a: Two { a: (), b: Two { a: Two { a: (), b: q }, b: () } }, b: () },
127+
//~^ ERROR the trait bound `Q: T1` is not satisfied [E0277]
128+
);
129+
}
130+
131+
fn main() {}

‎tests/ui/errors/traits/blame-trait-error-spans-on-exprs.stderr

Lines changed: 380 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,380 @@
1+
error[E0277]: the trait bound `Q: T3` is not satisfied
2+
--> $DIR/blame-trait-error-spans-on-exprs.rs:79:60
3+
|
4+
LL | want(Wrapper { value: Burrito { spicy: false, filling: q } });
5+
| ---- required by a bound introduced by this call ^ the trait `T3` is not implemented for `Q`
6+
|
7+
note: required for `Burrito<Q>` to implement `T2`
8+
--> $DIR/blame-trait-error-spans-on-exprs.rs:22:13
9+
|
10+
LL | impl<A: T3> T2 for Burrito<A> {}
11+
| -- ^^ ^^^^^^^^^^
12+
| |
13+
| unsatisfied trait bound introduced here
14+
note: required for `Wrapper<Burrito<Q>>` to implement `T1`
15+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
16+
|
17+
LL | impl<B: T2> T1 for Wrapper<B> {}
18+
| -- ^^ ^^^^^^^^^^
19+
| |
20+
| unsatisfied trait bound introduced here
21+
note: required by a bound in `want`
22+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
23+
|
24+
LL | fn want<V: T1>(_x: V) {}
25+
| ^^ required by this bound in `want`
26+
help: consider restricting type parameter `Q`
27+
|
28+
LL | fn example<Q: T3>(q: Q) {
29+
| ++++
30+
31+
error[E0277]: the trait bound `Q: T3` is not satisfied
32+
--> $DIR/blame-trait-error-spans-on-exprs.rs:83:84
33+
|
34+
LL | want(Wrapper { value: BurritoKinds::SmallBurrito { spicy: true, small_filling: q } });
35+
| ---- required by a bound introduced by this call ^ the trait `T3` is not implemented for `Q`
36+
|
37+
note: required for `BurritoKinds<Q>` to implement `T2`
38+
--> $DIR/blame-trait-error-spans-on-exprs.rs:32:13
39+
|
40+
LL | impl<D: T3> T2 for BurritoKinds<D> {}
41+
| -- ^^ ^^^^^^^^^^^^^^^
42+
| |
43+
| unsatisfied trait bound introduced here
44+
note: required for `Wrapper<BurritoKinds<Q>>` to implement `T1`
45+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
46+
|
47+
LL | impl<B: T2> T1 for Wrapper<B> {}
48+
| -- ^^ ^^^^^^^^^^
49+
| |
50+
| unsatisfied trait bound introduced here
51+
note: required by a bound in `want`
52+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
53+
|
54+
LL | fn want<V: T1>(_x: V) {}
55+
| ^^ required by this bound in `want`
56+
help: consider restricting type parameter `Q`
57+
|
58+
LL | fn example<Q: T3>(q: Q) {
59+
| ++++
60+
61+
error[E0277]: the trait bound `Q: T3` is not satisfied
62+
--> $DIR/blame-trait-error-spans-on-exprs.rs:87:39
63+
|
64+
LL | want(Wrapper { value: Taco(false, q) });
65+
| ---- ^ the trait `T3` is not implemented for `Q`
66+
| |
67+
| required by a bound introduced by this call
68+
|
69+
note: required for `Taco<Q>` to implement `T2`
70+
--> $DIR/blame-trait-error-spans-on-exprs.rs:35:13
71+
|
72+
LL | impl<E: T3> T2 for Taco<E> {}
73+
| -- ^^ ^^^^^^^
74+
| |
75+
| unsatisfied trait bound introduced here
76+
note: required for `Wrapper<Taco<Q>>` to implement `T1`
77+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
78+
|
79+
LL | impl<B: T2> T1 for Wrapper<B> {}
80+
| -- ^^ ^^^^^^^^^^
81+
| |
82+
| unsatisfied trait bound introduced here
83+
note: required by a bound in `want`
84+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
85+
|
86+
LL | fn want<V: T1>(_x: V) {}
87+
| ^^ required by this bound in `want`
88+
help: consider restricting type parameter `Q`
89+
|
90+
LL | fn example<Q: T3>(q: Q) {
91+
| ++++
92+
93+
error[E0277]: the trait bound `Q: T3` is not satisfied
94+
--> $DIR/blame-trait-error-spans-on-exprs.rs:91:27
95+
|
96+
LL | want(Wrapper { value: TacoKinds::OneTaco(false, q) });
97+
| ---- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `T3` is not implemented for `Q`
98+
| |
99+
| required by a bound introduced by this call
100+
|
101+
note: required for `TacoKinds<Q>` to implement `T2`
102+
--> $DIR/blame-trait-error-spans-on-exprs.rs:41:13
103+
|
104+
LL | impl<F: T3> T2 for TacoKinds<F> {}
105+
| -- ^^ ^^^^^^^^^^^^
106+
| |
107+
| unsatisfied trait bound introduced here
108+
note: required for `Wrapper<TacoKinds<Q>>` to implement `T1`
109+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
110+
|
111+
LL | impl<B: T2> T1 for Wrapper<B> {}
112+
| -- ^^ ^^^^^^^^^^
113+
| |
114+
| unsatisfied trait bound introduced here
115+
note: required by a bound in `want`
116+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
117+
|
118+
LL | fn want<V: T1>(_x: V) {}
119+
| ^^ required by this bound in `want`
120+
help: consider restricting type parameter `Q`
121+
|
122+
LL | fn example<Q: T3>(q: Q) {
123+
| ++++
124+
125+
error[E0277]: the trait bound `Q: T3` is not satisfied
126+
--> $DIR/blame-trait-error-spans-on-exprs.rs:95:74
127+
|
128+
LL | want(Wrapper { value: GenericBurrito { spiciness: NotSpicy, filling: q } });
129+
| ---- required by a bound introduced by this call ^ the trait `T3` is not implemented for `Q`
130+
|
131+
note: required for `GenericBurrito<NotSpicy, Q>` to implement `T2`
132+
--> $DIR/blame-trait-error-spans-on-exprs.rs:47:16
133+
|
134+
LL | impl<X, Y: T3> T2 for GenericBurrito<X, Y> {}
135+
| -- ^^ ^^^^^^^^^^^^^^^^^^^^
136+
| |
137+
| unsatisfied trait bound introduced here
138+
note: required for `Wrapper<GenericBurrito<NotSpicy, Q>>` to implement `T1`
139+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
140+
|
141+
LL | impl<B: T2> T1 for Wrapper<B> {}
142+
| -- ^^ ^^^^^^^^^^
143+
| |
144+
| unsatisfied trait bound introduced here
145+
note: required by a bound in `want`
146+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
147+
|
148+
LL | fn want<V: T1>(_x: V) {}
149+
| ^^ required by this bound in `want`
150+
help: consider restricting type parameter `Q`
151+
|
152+
LL | fn example<Q: T3>(q: Q) {
153+
| ++++
154+
155+
error[E0277]: the trait bound `Q: T2` is not satisfied
156+
--> $DIR/blame-trait-error-spans-on-exprs.rs:99:14
157+
|
158+
LL | want((3, q));
159+
| ---- ^ the trait `T2` is not implemented for `Q`
160+
| |
161+
| required by a bound introduced by this call
162+
|
163+
note: required for `(i32, Q)` to implement `T1`
164+
--> $DIR/blame-trait-error-spans-on-exprs.rs:51:20
165+
|
166+
LL | impl<A: T2, B: T2> T1 for (A, B) {}
167+
| -- ^^ ^^^^^^
168+
| |
169+
| unsatisfied trait bound introduced here
170+
note: required by a bound in `want`
171+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
172+
|
173+
LL | fn want<V: T1>(_x: V) {}
174+
| ^^ required by this bound in `want`
175+
help: consider restricting type parameter `Q`
176+
|
177+
LL | fn example<Q: T2>(q: Q) {
178+
| ++++
179+
180+
error[E0277]: the trait bound `Q: T3` is not satisfied
181+
--> $DIR/blame-trait-error-spans-on-exprs.rs:103:31
182+
|
183+
LL | want(Wrapper { value: (3, q) });
184+
| ---- ^ the trait `T3` is not implemented for `Q`
185+
| |
186+
| required by a bound introduced by this call
187+
|
188+
note: required for `(i32, Q)` to implement `T2`
189+
--> $DIR/blame-trait-error-spans-on-exprs.rs:50:20
190+
|
191+
LL | impl<A: T3, B: T3> T2 for (A, B) {}
192+
| -- ^^ ^^^^^^
193+
| |
194+
| unsatisfied trait bound introduced here
195+
note: required for `Wrapper<(i32, Q)>` to implement `T1`
196+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
197+
|
198+
LL | impl<B: T2> T1 for Wrapper<B> {}
199+
| -- ^^ ^^^^^^^^^^
200+
| |
201+
| unsatisfied trait bound introduced here
202+
note: required by a bound in `want`
203+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
204+
|
205+
LL | fn want<V: T1>(_x: V) {}
206+
| ^^ required by this bound in `want`
207+
help: consider restricting type parameter `Q`
208+
|
209+
LL | fn example<Q: T3>(q: Q) {
210+
| ++++
211+
212+
error[E0277]: the trait bound `Q: T3` is not satisfied
213+
--> $DIR/blame-trait-error-spans-on-exprs.rs:107:15
214+
|
215+
LL | want(((3, q), 5));
216+
| ---- ^ the trait `T3` is not implemented for `Q`
217+
| |
218+
| required by a bound introduced by this call
219+
|
220+
note: required for `(i32, Q)` to implement `T2`
221+
--> $DIR/blame-trait-error-spans-on-exprs.rs:50:20
222+
|
223+
LL | impl<A: T3, B: T3> T2 for (A, B) {}
224+
| -- ^^ ^^^^^^
225+
| |
226+
| unsatisfied trait bound introduced here
227+
note: required for `((i32, Q), i32)` to implement `T1`
228+
--> $DIR/blame-trait-error-spans-on-exprs.rs:51:20
229+
|
230+
LL | impl<A: T2, B: T2> T1 for (A, B) {}
231+
| -- ^^ ^^^^^^
232+
| |
233+
| unsatisfied trait bound introduced here
234+
note: required by a bound in `want`
235+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
236+
|
237+
LL | fn want<V: T1>(_x: V) {}
238+
| ^^ required by this bound in `want`
239+
help: consider restricting type parameter `Q`
240+
|
241+
LL | fn example<Q: T3>(q: Q) {
242+
| ++++
243+
244+
error[E0277]: the trait bound `Q: T1` is not satisfied
245+
--> $DIR/blame-trait-error-spans-on-exprs.rs:110:49
246+
|
247+
LL | want(DoubleWrapper { item: Wrapper { value: q } });
248+
| ---- ^ the trait `T1` is not implemented for `Q`
249+
| |
250+
| required by a bound introduced by this call
251+
|
252+
note: required for `DoubleWrapper<Q>` to implement `T1`
253+
--> $DIR/blame-trait-error-spans-on-exprs.rs:72:13
254+
|
255+
LL | impl<T: T1> T1 for DoubleWrapper<T> {}
256+
| -- ^^ ^^^^^^^^^^^^^^^^
257+
| |
258+
| unsatisfied trait bound introduced here
259+
note: required by a bound in `want`
260+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
261+
|
262+
LL | fn want<V: T1>(_x: V) {}
263+
| ^^ required by this bound in `want`
264+
help: consider restricting type parameter `Q`
265+
|
266+
LL | fn example<Q: T1>(q: Q) {
267+
| ++++
268+
269+
error[E0277]: the trait bound `Q: T1` is not satisfied
270+
--> $DIR/blame-trait-error-spans-on-exprs.rs:113:88
271+
|
272+
LL | want(DoubleWrapper { item: Wrapper { value: DoubleWrapper { item: Wrapper { value: q } } } });
273+
| ---- required by a bound introduced by this call ^ the trait `T1` is not implemented for `Q`
274+
|
275+
note: required for `DoubleWrapper<Q>` to implement `T1`
276+
--> $DIR/blame-trait-error-spans-on-exprs.rs:72:13
277+
|
278+
LL | impl<T: T1> T1 for DoubleWrapper<T> {}
279+
| -- ^^ ^^^^^^^^^^^^^^^^
280+
| |
281+
| unsatisfied trait bound introduced here
282+
= note: 1 redundant requirement hidden
283+
= note: required for `DoubleWrapper<DoubleWrapper<Q>>` to implement `T1`
284+
note: required by a bound in `want`
285+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
286+
|
287+
LL | fn want<V: T1>(_x: V) {}
288+
| ^^ required by this bound in `want`
289+
help: consider restricting type parameter `Q`
290+
|
291+
LL | fn example<Q: T1>(q: Q) {
292+
| ++++
293+
294+
error[E0277]: the trait bound `Q: T3` is not satisfied
295+
--> $DIR/blame-trait-error-spans-on-exprs.rs:117:27
296+
|
297+
LL | want(Wrapper { value: AliasBurrito { spiciness: q, filling: q } });
298+
| ---- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `T3` is not implemented for `Q`
299+
| |
300+
| required by a bound introduced by this call
301+
|
302+
note: required for `GenericBurrito<Q, Q>` to implement `T2`
303+
--> $DIR/blame-trait-error-spans-on-exprs.rs:47:16
304+
|
305+
LL | impl<X, Y: T3> T2 for GenericBurrito<X, Y> {}
306+
| -- ^^ ^^^^^^^^^^^^^^^^^^^^
307+
| |
308+
| unsatisfied trait bound introduced here
309+
note: required for `Wrapper<GenericBurrito<Q, Q>>` to implement `T1`
310+
--> $DIR/blame-trait-error-spans-on-exprs.rs:16:13
311+
|
312+
LL | impl<B: T2> T1 for Wrapper<B> {}
313+
| -- ^^ ^^^^^^^^^^
314+
| |
315+
| unsatisfied trait bound introduced here
316+
note: required by a bound in `want`
317+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
318+
|
319+
LL | fn want<V: T1>(_x: V) {}
320+
| ^^ required by this bound in `want`
321+
help: consider restricting type parameter `Q`
322+
|
323+
LL | fn example<Q: T3>(q: Q) {
324+
| ++++
325+
326+
error[E0277]: the trait bound `Q: T1` is not satisfied
327+
--> $DIR/blame-trait-error-spans-on-exprs.rs:120:35
328+
|
329+
LL | want(Two { a: Two { a: (), b: q }, b: () });
330+
| ---- ^ the trait `T1` is not implemented for `Q`
331+
| |
332+
| required by a bound introduced by this call
333+
|
334+
note: required for `Two<Two<(), Q>, ()>` to implement `T1`
335+
--> $DIR/blame-trait-error-spans-on-exprs.rs:66:19
336+
|
337+
LL | impl<X, Y: T1, Z> T1 for Two<Two<X, Y>, Z> {}
338+
| -- ^^ ^^^^^^^^^^^^^^^^^
339+
| |
340+
| unsatisfied trait bound introduced here
341+
note: required by a bound in `want`
342+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
343+
|
344+
LL | fn want<V: T1>(_x: V) {}
345+
| ^^ required by this bound in `want`
346+
help: consider restricting type parameter `Q`
347+
|
348+
LL | fn example<Q: T1>(q: Q) {
349+
| ++++
350+
351+
error[E0277]: the trait bound `Q: T1` is not satisfied
352+
--> $DIR/blame-trait-error-spans-on-exprs.rs:126:59
353+
|
354+
LL | want(
355+
| ---- required by a bound introduced by this call
356+
LL | Two { a: Two { a: (), b: Two { a: Two { a: (), b: q }, b: () } }, b: () },
357+
| ^ the trait `T1` is not implemented for `Q`
358+
|
359+
note: required for `Two<Two<(), Q>, ()>` to implement `T1`
360+
--> $DIR/blame-trait-error-spans-on-exprs.rs:66:19
361+
|
362+
LL | impl<X, Y: T1, Z> T1 for Two<Two<X, Y>, Z> {}
363+
| -- ^^ ^^^^^^^^^^^^^^^^^
364+
| |
365+
| unsatisfied trait bound introduced here
366+
= note: 1 redundant requirement hidden
367+
= note: required for `Two<Two<(), Two<Two<(), Q>, ()>>, ()>` to implement `T1`
368+
note: required by a bound in `want`
369+
--> $DIR/blame-trait-error-spans-on-exprs.rs:53:12
370+
|
371+
LL | fn want<V: T1>(_x: V) {}
372+
| ^^ required by this bound in `want`
373+
help: consider restricting type parameter `Q`
374+
|
375+
LL | fn example<Q: T1>(q: Q) {
376+
| ++++
377+
378+
error: aborting due to 13 previous errors
379+
380+
For more information about this error, try `rustc --explain E0277`.

‎tests/ui/traits/negative-impls/negated-auto-traits-error.stderr

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,10 +101,10 @@ LL | fn is_send<T: Send>(_: T) {}
101101
| ^^^^ required by this bound in `is_send`
102102

103103
error[E0277]: `main::TestType` cannot be sent between threads safely
104-
--> $DIR/negated-auto-traits-error.rs:66:13
104+
--> $DIR/negated-auto-traits-error.rs:66:20
105105
|
106106
LL | is_sync(Outer2(TestType));
107-
| ------- ^^^^^^^^^^^^^^^^ `main::TestType` cannot be sent between threads safely
107+
| ------- ^^^^^^^^ `main::TestType` cannot be sent between threads safely
108108
| |
109109
| required by a bound introduced by this call
110110
|

0 commit comments

Comments
 (0)
Please sign in to comment.