Use head span for rustc_on_unimplemented's enclosing_scope attr

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -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);
                         }

src/test/ui/on-unimplemented/enclosing-scope.stderr

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

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

@@ -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 | fn nested_within_if_expr() {
-LL | |     if &let 0 = 0 {}
+   | -------------------------- this function should return `Result` or `Option` to accept `?`
-LL | |
+...
-LL | |
+LL |     if (let 0 = 0)? {}
-...  |
+   |                   ^ cannot use the `?` operator in a function that returns `()`
-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 `?`
    |
    = 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 | fn nested_within_while_expr() {
-LL | |     while &let 0 = 0 {}
+   | ----------------------------- this function should return `Result` or `Option` to accept `?`
-LL | |
+...
-LL | |
+LL |     while (let 0 = 0)? {}
-...  |
+   |                      ^ cannot use the `?` operator in a function that returns `()`
-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 `?`
    |
    = 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 | fn outside_if_and_while_expr() {
-LL | |     &let 0 = 0;
+   | ------------------------------ this function should return `Result` or `Option` to accept `?`
-LL | |
+...
-LL | |
+LL |     (let 0 = 0)?;
-...  |
+   |                ^ cannot use the `?` operator in a function that returns `()`
-LL | |     (let 0 = 0)?;
-   | |                ^ cannot use the `?` operator in a function that returns `()`
-...  |
-LL | |
-LL | | }
-   | |_- this function should return `Result` or `Option` to accept `?`
    |
    = help: the trait `FromResidual<_>` is not implemented for `()`
 

src/test/ui/try-trait/bad-interconversion.stderr

@@ -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 | fn option_to_result() -> Result<u64, String> {
-LL | |     Some(3)?;
+   | -------------------------------------------- this function returns a `Result`
-   | |            ^ use `.ok_or(...)?` to provide an error compatible with `Result<u64, String>`
+LL |     Some(3)?;
-LL | |
+   |            ^ use `.ok_or(...)?` to provide an error compatible with `Result<u64, String>`
-LL | |     Ok(10)
-LL | | }
-   | |_- this function returns a `Result`
    |
    = 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 | fn control_flow_to_result() -> Result<u64, String> {
-LL | |     Ok(ControlFlow::Break(123)?)
+   | -------------------------------------------------- this function returns a `Result`
-   | |                               ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Result<u64, String>`
+LL |     Ok(ControlFlow::Break(123)?)
-LL | |
+   |                               ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Result<u64, String>`
-LL | | }
-   | |_- this function returns a `Result`
    |
    = 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 | fn result_to_option() -> Option<u16> {
-LL | |     Some(Err("hello")?)
+   | ------------------------------------ this function returns an `Option`
-   | |                      ^ use `.ok()?` if you want to discard the `Result<Infallible, &str>` error information
+LL |     Some(Err("hello")?)
-LL | |
+   |                      ^ use `.ok()?` if you want to discard the `Result<Infallible, &str>` error information
-LL | | }
-   | |_- this function returns an `Option`
    |
    = 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 | fn control_flow_to_option() -> Option<u64> {
-LL | |     Some(ControlFlow::Break(123)?)
+   | ------------------------------------------ this function returns an `Option`
-   | |                                 ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Option<u64>`
+LL |     Some(ControlFlow::Break(123)?)
-LL | |
+   |                                 ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Option<u64>`
-LL | | }
-   | |_- this function returns an `Option`
    |
    = 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 | fn result_to_control_flow() -> ControlFlow<String> {
-LL | |     ControlFlow::Continue(Err("hello")?)
+   | -------------------------------------------------- this function returns a `ControlFlow`
-   | |                                       ^ this `?` produces `Result<Infallible, &str>`, which is incompatible with `ControlFlow<String>`
+LL |     ControlFlow::Continue(Err("hello")?)
-LL | |
+   |                                       ^ this `?` produces `Result<Infallible, &str>`, which is incompatible with `ControlFlow<String>`
-LL | | }
-   | |_- this function returns a `ControlFlow`
    |
    = 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 | fn option_to_control_flow() -> ControlFlow<u64> {
-LL | |     Some(3)?;
+   | ----------------------------------------------- this function returns a `ControlFlow`
-   | |            ^ this `?` produces `Option<Infallible>`, which is incompatible with `ControlFlow<u64>`
+LL |     Some(3)?;
-LL | |
+   |            ^ this `?` produces `Option<Infallible>`, which is incompatible with `ControlFlow<u64>`
-LL | |     ControlFlow::Break(10)
-LL | | }
-   | |_- this function returns a `ControlFlow`
    |
    = 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 | fn control_flow_to_control_flow() -> ControlFlow<i64> {
-LL | |     ControlFlow::Break(4_u8)?;
+   | ----------------------------------------------------- this function returns a `ControlFlow`
-   | |                             ^ this `?` produces `ControlFlow<u8, Infallible>`, which is incompatible with `ControlFlow<i64>`
+LL |     ControlFlow::Break(4_u8)?;
-LL | |
+   |                             ^ this `?` produces `ControlFlow<u8, Infallible>`, which is incompatible with `ControlFlow<i64>`
-LL | |     ControlFlow::Continue(())
-LL | | }
-   | |_- this function returns a `ControlFlow`
    |
    = help: the trait `FromResidual<ControlFlow<u8, Infallible>>` is not implemented for `ControlFlow<i64>`
    = note: unlike `Result`, there's no `From`-conversion performed for `ControlFlow`

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

@@ -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 | fn test_result() -> Result<(),()> {
-LL | |     let a:Option<()> = Some(());
+   | --------------------------------- this function returns a `Result`
-LL | |     a?;
+LL |     let a:Option<()> = Some(());
-   | |      ^ use `.ok_or(...)?` to provide an error compatible with `Result<(), ()>`
+LL |     a?;
-LL | |     Ok(())
+   |      ^ use `.ok_or(...)?` to provide an error compatible with `Result<(), ()>`
-LL | | }
-   | |_- this function returns a `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 | fn test_option() -> Option<i32>{
-LL | |     let a:Result<i32, i32> = Ok(5);
+   | ------------------------------- this function returns an `Option`
-LL | |     a?;
+LL |     let a:Result<i32, i32> = Ok(5);
-   | |      ^ use `.ok()?` if you want to discard the `Result<Infallible, i32>` error information
+LL |     a?;
-LL | |     Some(5)
+   |      ^ use `.ok()?` if you want to discard the `Result<Infallible, i32>` error information
-LL | | }
-   | |_- this function returns an `Option`
    |
    = help: the trait `FromResidual<Result<Infallible, i32>>` is not implemented for `Option<i32>`
    = help: the following other types implement trait `FromResidual<R>`:

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

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

src/test/ui/try-trait/try-on-option.stderr

@@ -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 | fn foo() -> Result<u32, ()> {
-LL | |     let x: Option<u32> = None;
+   | --------------------------- this function returns a `Result`
-LL | |     x?;
+LL |     let x: Option<u32> = None;
-   | |      ^ use `.ok_or(...)?` to provide an error compatible with `Result<u32, ()>`
+LL |     x?;
-LL | |     Ok(22)
+   |      ^ use `.ok_or(...)?` to provide an error compatible with `Result<u32, ()>`
-LL | | }
-   | |_- this function returns a `Result`
    |
    = 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 | fn bar() -> u32 {
-LL | |     let x: Option<u32> = None;
+   | --------------- this function should return `Result` or `Option` to accept `?`
-LL | |     x?;
+LL |     let x: Option<u32> = None;
-   | |      ^ cannot use the `?` operator in a function that returns `u32`
+LL |     x?;
-LL | |     22
+   |      ^ cannot use the `?` operator in a function that returns `u32`
-LL | | }
-   | |_- this function should return `Result` or `Option` to accept `?`
    |
    = help: the trait `FromResidual<Option<Infallible>>` is not implemented for `u32`
 

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

@@ -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 | fn main() {
-LL | |     // error for a `Try` type on a non-`Try` fn
+   | --------- this function should return `Result` or `Option` to accept `?`
-LL | |     std::fs::File::open("foo")?;
+LL |     // error for a `Try` type on a non-`Try` fn
-   | |                               ^ cannot use the `?` operator in a function that returns `()`
+LL |     std::fs::File::open("foo")?;
-LL | |
+   |                               ^ cannot use the `?` operator in a function that returns `()`
-...  |
-LL | |     try_trait_generic::<()>();
-LL | | }
-   | |_- this function should return `Result` or `Option` to accept `?`
    |
    = 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 | fn main() {
-LL | |     // error for a `Try` type on a non-`Try` fn
+   | --------- this function should return `Result` or `Option` to accept `?`
-LL | |     std::fs::File::open("foo")?;
+...
-LL | |
+LL |     ()?;
-LL | |     // a non-`Try` type on a non-`Try` fn
+   |       ^ cannot use the `?` operator in a function that returns `()`
-LL | |     ()?;
-   | |       ^ cannot use the `?` operator in a function that returns `()`
-...  |
-LL | |     try_trait_generic::<()>();
-LL | | }
-   | |_- this function should return `Result` or `Option` to accept `?`
    |
    = help: the trait `FromResidual<_>` is not implemented for `()`