bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Use head span for rustc_on_unimplemented's enclosing_scope attr

Browse source
This commit is contained in:
Michael Goulet 2022-09-01 19:52:39 +00:00
parent 84f0c3f79a
commit c23fe81764
8 changed files with 120 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -526,7 +526,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
});
let enclosing_scope_span =
tcx.hir().span_with_body(tcx.hir().local_def_id_to_hir_id(body));
tcx.hir().span(tcx.hir().local_def_id_to_hir_id(body));
err.span_label(enclosing_scope_span, s);
}

65
src/test/ui/on-unimplemented/enclosing-scope.stderr
View file

@ -2,16 +2,11 @@ error[E0277]: the trait bound `Foo: Trait` is not satisfied
--> $DIR/enclosing-scope.rs:14:11
|
LL | let x = || {
| _____________-
LL | | f(Foo{});
| | - ^^^^^ the trait `Trait` is not implemented for `Foo`
| | |
| | required by a bound introduced by this call
LL | | let y = || {
LL | | f(Foo{});
LL | | };
LL | | };
| |_____- in this scope
| -- in this scope
LL | f(Foo{});
| - ^^^^^ the trait `Trait` is not implemented for `Foo`
| |
| required by a bound introduced by this call
|
note: required by a bound in `f`
--> $DIR/enclosing-scope.rs:10:9
@ -23,13 +18,11 @@ error[E0277]: the trait bound `Foo: Trait` is not satisfied
--> $DIR/enclosing-scope.rs:16:15
|
LL | let y = || {
| _________________-
LL | | f(Foo{});
| | - ^^^^^ the trait `Trait` is not implemented for `Foo`
| | |
| | required by a bound introduced by this call
LL | | };
| |_________- in this scope
| -- in this scope
LL | f(Foo{});
| - ^^^^^ the trait `Trait` is not implemented for `Foo`
| |
| required by a bound introduced by this call
|
note: required by a bound in `f`
--> $DIR/enclosing-scope.rs:10:9
@ -40,19 +33,13 @@ LL | fn f<T: Trait>(x: T) {}
error[E0277]: the trait bound `Foo: Trait` is not satisfied
--> $DIR/enclosing-scope.rs:22:15
|
LL | / fn main() {
LL | | let x = || {
LL | | f(Foo{});
LL | | let y = || {
... |
LL | | f(Foo{});
| | - ^^^^^ the trait `Trait` is not implemented for `Foo`
| | |
| | required by a bound introduced by this call
... |
LL | | f(Foo{});
LL | | }
| |_- in this scope
LL | fn main() {
| --------- in this scope
...
LL | f(Foo{});
| - ^^^^^ the trait `Trait` is not implemented for `Foo`
| |
| required by a bound introduced by this call
|
note: required by a bound in `f`
--> $DIR/enclosing-scope.rs:10:9
@ -63,17 +50,13 @@ LL | fn f<T: Trait>(x: T) {}
error[E0277]: the trait bound `Foo: Trait` is not satisfied
--> $DIR/enclosing-scope.rs:26:7
|
LL | / fn main() {
LL | | let x = || {
LL | | f(Foo{});
LL | | let y = || {
... |
LL | | f(Foo{});
| | - ^^^^^ the trait `Trait` is not implemented for `Foo`
| | |
| | required by a bound introduced by this call
LL | | }
| |_- in this scope
LL | fn main() {
| --------- in this scope
...
LL | f(Foo{});
| - ^^^^^ the trait `Trait` is not implemented for `Foo`
| |
| required by a bound introduced by this call
|
note: required by a bound in `f`
--> $DIR/enclosing-scope.rs:10:9

48
src/test/ui/rfc-2497-if-let-chains/disallowed-positions.stderr
View file

@ -1493,17 +1493,11 @@ LL | if (let 0 = 0)? {}
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/disallowed-positions.rs:132:19
|
LL | / fn nested_within_if_expr() {
LL | | if &let 0 = 0 {}
LL | |
LL | |
... |
LL | | if (let 0 = 0)? {}
| | ^ cannot use the `?` operator in a function that returns `()`
... |
LL | |
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn nested_within_if_expr() {
| -------------------------- this function should return `Result` or `Option` to accept `?`
...
LL | if (let 0 = 0)? {}
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
@ -1693,17 +1687,11 @@ LL | while (let 0 = 0)? {}
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/disallowed-positions.rs:224:22
|
LL | / fn nested_within_while_expr() {
LL | | while &let 0 = 0 {}
LL | |
LL | |
... |
LL | | while (let 0 = 0)? {}
| | ^ cannot use the `?` operator in a function that returns `()`
... |
LL | |
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn nested_within_while_expr() {
| ----------------------------- this function should return `Result` or `Option` to accept `?`
...
LL | while (let 0 = 0)? {}
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`
@ -1881,17 +1869,11 @@ LL | (let 0 = 0)?;
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/disallowed-positions.rs:325:16
|
LL | / fn outside_if_and_while_expr() {
LL | | &let 0 = 0;
LL | |
LL | |
... |
LL | | (let 0 = 0)?;
| | ^ cannot use the `?` operator in a function that returns `()`
... |
LL | |
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn outside_if_and_while_expr() {
| ------------------------------ this function should return `Result` or `Option` to accept `?`
...
LL | (let 0 = 0)?;
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`

73
src/test/ui/try-trait/bad-interconversion.stderr
View file

@ -22,13 +22,10 @@ LL | Ok(Err(123_i32)?)
error[E0277]: the `?` operator can only be used on `Result`s, not `Option`s, in a function that returns `Result`
--> $DIR/bad-interconversion.rs:11:12
|
LL | / fn option_to_result() -> Result<u64, String> {
LL | | Some(3)?;
| | ^ use `.ok_or(...)?` to provide an error compatible with `Result<u64, String>`
LL | |
LL | | Ok(10)
LL | | }
| |_- this function returns a `Result`
LL | fn option_to_result() -> Result<u64, String> {
| -------------------------------------------- this function returns a `Result`
LL | Some(3)?;
| ^ use `.ok_or(...)?` to provide an error compatible with `Result<u64, String>`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `Result<u64, String>`
= help: the following other types implement trait `FromResidual<R>`:
@ -38,12 +35,10 @@ LL | | }
error[E0277]: the `?` operator can only be used on `Result`s in a function that returns `Result`
--> $DIR/bad-interconversion.rs:17:31
|
LL | / fn control_flow_to_result() -> Result<u64, String> {
LL | | Ok(ControlFlow::Break(123)?)
| | ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Result<u64, String>`
LL | |
LL | | }
| |_- this function returns a `Result`
LL | fn control_flow_to_result() -> Result<u64, String> {
| -------------------------------------------------- this function returns a `Result`
LL | Ok(ControlFlow::Break(123)?)
| ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Result<u64, String>`
|
= help: the trait `FromResidual<ControlFlow<{integer}, Infallible>>` is not implemented for `Result<u64, String>`
= help: the following other types implement trait `FromResidual<R>`:
@ -53,12 +48,10 @@ LL | | }
error[E0277]: the `?` operator can only be used on `Option`s, not `Result`s, in a function that returns `Option`
--> $DIR/bad-interconversion.rs:22:22
|
LL | / fn result_to_option() -> Option<u16> {
LL | | Some(Err("hello")?)
| | ^ use `.ok()?` if you want to discard the `Result<Infallible, &str>` error information
LL | |
LL | | }
| |_- this function returns an `Option`
LL | fn result_to_option() -> Option<u16> {
| ------------------------------------ this function returns an `Option`
LL | Some(Err("hello")?)
| ^ use `.ok()?` if you want to discard the `Result<Infallible, &str>` error information
|
= help: the trait `FromResidual<Result<Infallible, &str>>` is not implemented for `Option<u16>`
= help: the following other types implement trait `FromResidual<R>`:
@ -68,12 +61,10 @@ LL | | }
error[E0277]: the `?` operator can only be used on `Option`s in a function that returns `Option`
--> $DIR/bad-interconversion.rs:27:33
|
LL | / fn control_flow_to_option() -> Option<u64> {
LL | | Some(ControlFlow::Break(123)?)
| | ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Option<u64>`
LL | |
LL | | }
| |_- this function returns an `Option`
LL | fn control_flow_to_option() -> Option<u64> {
| ------------------------------------------ this function returns an `Option`
LL | Some(ControlFlow::Break(123)?)
| ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Option<u64>`
|
= help: the trait `FromResidual<ControlFlow<{integer}, Infallible>>` is not implemented for `Option<u64>`
= help: the following other types implement trait `FromResidual<R>`:
@ -83,12 +74,10 @@ LL | | }
error[E0277]: the `?` operator can only be used on `ControlFlow`s in a function that returns `ControlFlow`
--> $DIR/bad-interconversion.rs:32:39
|
LL | / fn result_to_control_flow() -> ControlFlow<String> {
LL | | ControlFlow::Continue(Err("hello")?)
| | ^ this `?` produces `Result<Infallible, &str>`, which is incompatible with `ControlFlow<String>`
LL | |
LL | | }
| |_- this function returns a `ControlFlow`
LL | fn result_to_control_flow() -> ControlFlow<String> {
| -------------------------------------------------- this function returns a `ControlFlow`
LL | ControlFlow::Continue(Err("hello")?)
| ^ this `?` produces `Result<Infallible, &str>`, which is incompatible with `ControlFlow<String>`
|
= help: the trait `FromResidual<Result<Infallible, &str>>` is not implemented for `ControlFlow<String>`
= help: the trait `FromResidual` is implemented for `ControlFlow<B, C>`
@ -96,13 +85,10 @@ LL | | }
error[E0277]: the `?` operator can only be used on `ControlFlow`s in a function that returns `ControlFlow`
--> $DIR/bad-interconversion.rs:37:12
|
LL | / fn option_to_control_flow() -> ControlFlow<u64> {
LL | | Some(3)?;
| | ^ this `?` produces `Option<Infallible>`, which is incompatible with `ControlFlow<u64>`
LL | |
LL | | ControlFlow::Break(10)
LL | | }
| |_- this function returns a `ControlFlow`
LL | fn option_to_control_flow() -> ControlFlow<u64> {
| ----------------------------------------------- this function returns a `ControlFlow`
LL | Some(3)?;
| ^ this `?` produces `Option<Infallible>`, which is incompatible with `ControlFlow<u64>`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `ControlFlow<u64>`
= help: the trait `FromResidual` is implemented for `ControlFlow<B, C>`
@ -110,13 +96,10 @@ LL | | }
error[E0277]: the `?` operator in a function that returns `ControlFlow<B, _>` can only be used on other `ControlFlow<B, _>`s (with the same Break type)
--> $DIR/bad-interconversion.rs:43:29
|
LL | / fn control_flow_to_control_flow() -> ControlFlow<i64> {
LL | | ControlFlow::Break(4_u8)?;
| | ^ this `?` produces `ControlFlow<u8, Infallible>`, which is incompatible with `ControlFlow<i64>`
LL | |
LL | | ControlFlow::Continue(())
LL | | }
| |_- this function returns a `ControlFlow`
LL | fn control_flow_to_control_flow() -> ControlFlow<i64> {
| ----------------------------------------------------- this function returns a `ControlFlow`
LL | ControlFlow::Break(4_u8)?;
| ^ this `?` produces `ControlFlow<u8, Infallible>`, which is incompatible with `ControlFlow<i64>`
|
= help: the trait `FromResidual<ControlFlow<u8, Infallible>>` is not implemented for `ControlFlow<i64>`
= note: unlike `Result`, there's no `From`-conversion performed for `ControlFlow`

24
src/test/ui/try-trait/option-to-result.stderr
View file

@ -1,13 +1,11 @@
error[E0277]: the `?` operator can only be used on `Result`s, not `Option`s, in a function that returns `Result`
--> $DIR/option-to-result.rs:5:6
|
LL | / fn test_result() -> Result<(),()> {
LL | | let a:Option<()> = Some(());
LL | | a?;
| | ^ use `.ok_or(...)?` to provide an error compatible with `Result<(), ()>`
LL | | Ok(())
LL | | }
| |_- this function returns a `Result`
LL | fn test_result() -> Result<(),()> {
| --------------------------------- this function returns a `Result`
LL | let a:Option<()> = Some(());
LL | a?;
| ^ use `.ok_or(...)?` to provide an error compatible with `Result<(), ()>`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `Result<(), ()>`
= help: the following other types implement trait `FromResidual<R>`:
@ -17,13 +15,11 @@ LL | | }
error[E0277]: the `?` operator can only be used on `Option`s, not `Result`s, in a function that returns `Option`
--> $DIR/option-to-result.rs:11:6
|
LL | / fn test_option() -> Option<i32>{
LL | | let a:Result<i32, i32> = Ok(5);
LL | | a?;
| | ^ use `.ok()?` if you want to discard the `Result<Infallible, i32>` error information
LL | | Some(5)
LL | | }
| |_- this function returns an `Option`
LL | fn test_option() -> Option<i32>{
| ------------------------------- this function returns an `Option`
LL | let a:Result<i32, i32> = Ok(5);
LL | a?;
| ^ use `.ok()?` if you want to discard the `Result<Infallible, i32>` error information
|
= help: the trait `FromResidual<Result<Infallible, i32>>` is not implemented for `Option<i32>`
= help: the following other types implement trait `FromResidual<R>`:

45
src/test/ui/try-trait/try-on-option-diagnostics.stderr
View file

@ -1,13 +1,11 @@
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-on-option-diagnostics.rs:7:6
|
LL | / fn a_function() -> u32 {
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ cannot use the `?` operator in a function that returns `u32`
LL | | 22
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn a_function() -> u32 {
| ---------------------- this function should return `Result` or `Option` to accept `?`
LL | let x: Option<u32> = None;
LL | x?;
| ^ cannot use the `?` operator in a function that returns `u32`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `u32`
@ -15,37 +13,32 @@ error[E0277]: the `?` operator can only be used in a closure that returns `Resul
--> $DIR/try-on-option-diagnostics.rs:14:10
|
LL | let a_closure = || {
| _____________________-
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ cannot use the `?` operator in a closure that returns `{integer}`
LL | | 22
LL | | };
| |_____- this function should return `Result` or `Option` to accept `?`
| -- this function should return `Result` or `Option` to accept `?`
LL | let x: Option<u32> = None;
LL | x?;
| ^ cannot use the `?` operator in a closure that returns `{integer}`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `{integer}`
error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-on-option-diagnostics.rs:26:14
|
LL | / fn a_method() {
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ cannot use the `?` operator in a method that returns `()`
LL | | }
| |_________- this function should return `Result` or `Option` to accept `?`
LL | fn a_method() {
| ------------- this function should return `Result` or `Option` to accept `?`
LL | let x: Option<u32> = None;
LL | x?;
| ^ cannot use the `?` operator in a method that returns `()`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `()`
error[E0277]: the `?` operator can only be used in a trait method that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-on-option-diagnostics.rs:39:14
|
LL | / fn a_trait_method() {
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ cannot use the `?` operator in a trait method that returns `()`
LL | | }
| |_________- this function should return `Result` or `Option` to accept `?`
LL | fn a_trait_method() {
| ------------------- this function should return `Result` or `Option` to accept `?`
LL | let x: Option<u32> = None;
LL | x?;
| ^ cannot use the `?` operator in a trait method that returns `()`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `()`

24
src/test/ui/try-trait/try-on-option.stderr
View file

@ -1,13 +1,11 @@
error[E0277]: the `?` operator can only be used on `Result`s, not `Option`s, in a function that returns `Result`
--> $DIR/try-on-option.rs:5:6
|
LL | / fn foo() -> Result<u32, ()> {
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ use `.ok_or(...)?` to provide an error compatible with `Result<u32, ()>`
LL | | Ok(22)
LL | | }
| |_- this function returns a `Result`
LL | fn foo() -> Result<u32, ()> {
| --------------------------- this function returns a `Result`
LL | let x: Option<u32> = None;
LL | x?;
| ^ use `.ok_or(...)?` to provide an error compatible with `Result<u32, ()>`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `Result<u32, ()>`
= help: the following other types implement trait `FromResidual<R>`:
@ -17,13 +15,11 @@ LL | | }
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-on-option.rs:11:6
|
LL | / fn bar() -> u32 {
LL | | let x: Option<u32> = None;
LL | | x?;
| | ^ cannot use the `?` operator in a function that returns `u32`
LL | | 22
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn bar() -> u32 {
| --------------- this function should return `Result` or `Option` to accept `?`
LL | let x: Option<u32> = None;
LL | x?;
| ^ cannot use the `?` operator in a function that returns `u32`
|
= help: the trait `FromResidual<Option<Infallible>>` is not implemented for `u32`

30
src/test/ui/try-trait/try-operator-on-main.stderr
View file

@ -1,15 +1,11 @@
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-operator-on-main.rs:7:31
|
LL | / fn main() {
LL | | // error for a `Try` type on a non-`Try` fn
LL | | std::fs::File::open("foo")?;
| | ^ cannot use the `?` operator in a function that returns `()`
LL | |
... |
LL | | try_trait_generic::<()>();
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn main() {
| --------- this function should return `Result` or `Option` to accept `?`
LL | // error for a `Try` type on a non-`Try` fn
LL | std::fs::File::open("foo")?;
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
@ -24,17 +20,11 @@ LL | ()?;
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
--> $DIR/try-operator-on-main.rs:10:7
|
LL | / fn main() {
LL | | // error for a `Try` type on a non-`Try` fn
LL | | std::fs::File::open("foo")?;
LL | |
LL | | // a non-`Try` type on a non-`Try` fn
LL | | ()?;
| | ^ cannot use the `?` operator in a function that returns `()`
... |
LL | | try_trait_generic::<()>();
LL | | }
| |_- this function should return `Result` or `Option` to accept `?`
LL | fn main() {
| --------- this function should return `Result` or `Option` to accept `?`
...
LL | ()?;
| ^ cannot use the `?` operator in a function that returns `()`
|
= help: the trait `FromResidual<_>` is not implemented for `()`