!Sized return type error panics with 'no errors encountered even though delay_span_bug issued'

[QuineDot]

Code

use std::ops::BitOr;

pub trait IntWrapper {
    type InternalStorage;
}

impl<T> BitOr for dyn IntWrapper<InternalStorage = T>
where
    Self: Sized,
    T: BitOr + BitOr<Output = T>,
{
    type Output = Self;
    fn bitor(self, _other: Self) -> Self {
        todo!()
    }
}

Meta

Via the playground on all of stable, beta, and nightly.

note: rustc 1.48.0 (7eac88a 2020-11-16) running on x86_64-unknown-linux-gnu
note: compiler flags: -C embed-bitcode=no -C codegen-units=1 -C debuginfo=2 --crate-type lib
note: some of the compiler flags provided by cargo are hidden

Error output

   Compiling playground v0.0.1 (/playground)
error: internal compiler error: `!Sized` return type
  --> src/lib.rs:13:37
   |
13 |     fn bitor(self, _other: Self) -> Self {
   |                                     ^^^^
   |
   = note: delayed at compiler/rustc_typeck/src/check/check.rs:154:18

thread 'rustc' panicked at 'no errors encountered even though `delay_span_bug` issued', compiler/rustc_errors/src/lib.rs:961:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

Credit

Discovered by rectang as reported on the user forum.

[rectang]

A further reduction clarifies that the bug has nothing to do with std::ops::BitOr.

pub trait Foo {
    fn do_stuff() -> Self;
}

pub trait Bar {
    type Output;
}

impl<T> Foo for dyn Bar<Output = T>
where
    Self: Sized,
{
    fn do_stuff() -> Self {
        todo!()
    }
}

[SNCPlay42]

This code compiled successfully in 1.44 and earlier. The delay_span_bug it's hitting was added in #70998 (here).

@rustbot label regression-from-stable-to-stable A-dst

[camelid]

Assigning P-high and removing I-prioritize as discussed in the prioritization working group.

[osa1]

The delay_span_bug in this ICE is this one:

rust/compiler/rustc_typeck/src/check/check.rs

Lines 182 to 195 in 742c972

	// FIXME: We need to verify that the return type is `Sized` after the return expression has
	// been evaluated so that we have types available for all the nodes being returned, but that
	// requires the coerced evaluated type to be stored. Moving `check_return_expr` before this
	// causes unsized errors caused by the `declared_ret_ty` to point at the return expression,
	// while keeping the current ordering we will ignore the tail expression's type because we
	// don't know it yet. We can't do `check_expr_kind` while keeping `check_return_expr`
	// because we will trigger "unreachable expression" lints unconditionally.
	// Because of all of this, we perform a crude check to know whether the simplest `!Sized`
	// case that a newcomer might make, returning a bare trait, and in that case we populate
	// the tail expression's type so that the suggestion will be correct, but ignore all other
	// possible cases.
	fcx.check_expr(&body.value);
	fcx.require_type_is_sized(declared_ret_ty, decl.output.span(), traits::SizedReturnType);
	tcx.sess.delay_span_bug(decl.output.span(), "`!Sized` return type");

It was added in e536257.

I think the problem with this program is that we have Self: Sized but the self is actually dyn <trait> which is not Sized, right? So we don't expect to compile it, we should just reject it with a good error message?

Pinging @estebank as he is the author of the commit above.

[estebank]

It would be nice if we could come up with more repro cases that don't involve Self. It'd be easy to fix only this one case but I'm struggling to see what other cases could trigger this.

[estebank]

As mentioned in the pr fixing this, the delay_span_bug was incorrect. It should have never been added.

[estebank]

Reopening for the backport.