Object safety does not consider supertraits

[emberian]

The following code either aborts or segfaults for me, depending on if I'm in gdb or not, on Linux:

pub trait ExtTrait for Sized? {
    fn ext(&self);
}

pub trait Foo for Sized? {
    fn foo<Sized? T>(&mut self, ext_thing: &T) where T: ExtTrait;
}

pub trait Bar for Sized?: Foo { }

impl<'a> Foo for Bar + 'a {
    fn foo<Sized? T>(&mut self, ext_thing: &T) where T: ExtTrait {
        (*self).foo(ext_thing);
    }
}

impl<T: Foo> Bar for T { }

pub struct Thing;

impl Foo for Thing {
    fn foo<Sized? T>(&mut self, _: &T) where T: ExtTrait {
        println!("Thing::Foo::foo begin");
    }
}

pub struct Supporting;

impl ExtTrait for Supporting {
    fn ext(&self) {
        println!("Supporting::ExtTrait::ext");
    }
}

fn main() {
    let mut thing = Thing;
    let ext_thing = Supporting;
    let test: &mut Bar = &mut thing;

    test.foo(&ext_thing);
}

With optimizations, main becomes

define internal void @_ZN4main20h337c4f395fd4e2e64caE() unnamed_addr #0 {
entry-block:
  tail call void @llvm.trap()
  unreachable
}

Which means we're doing something very bad when translating this code.

[emberian]

Still reducing...

[msiemens]

FWIW, I can confirm that behaviour on Windows.

[nikomatsakis]

cc me

[arielb1]

Reduced:

pub trait Foo for Sized? { fn foo<T>(&self, ext_thing: &T); }
pub trait Bar for Sized?: Foo { }
impl<T: Foo> Bar for T { }

pub struct Thing;
impl Foo for Thing {
    fn foo<T>(&self, _: &T) {}
}

#[inline(never)] fn foo(b: &Bar) { b.foo(&0u) }

fn main() {
    let mut thing = Thing;
    let test: &Bar = &mut thing;
    foo(test);
}

And that makes it clear the issue is not broken codegen, but rather that Bar is mistakenly treated as object-safe (while it inherits from the non-object-safe Foo).

[nikomatsakis]

@arielb1 nice.

cc @nick29581

[pnkfelix]

P-backcompat-lang, 1.0.

[nikomatsakis]

Hint: iterate with traits::supertraits

[emberian]

@nikomatsakis supertraits takes/creates Rc<TraitRef>s but check_object_safety needs a TyTrait. I'm not sure how to make these agree.

[nikomatsakis]

@cmr check_object_safety should use supertraits to enumerate the principal trait_ref, I think. Annoyingly this does require a Rc::new(principle.clone()) right now (harder to fix than you might think).

[emberian]

On my branch I get this panic, which is an unwrap in self_ty in the supertraits iterator.