Compiler crash when implementing a trait with unmet supertrait bound

[Anonymous1-design]

Code

trait UnitValue: NewTrait {
    fn value(&self) -> i32;
}
impl UnitValue for i32 {
    fn value(&self) -> i32 {
        *self
    }
}
trait UnitExt: UnitValue {
    fn double_value(&self) -> i32 {
        self.value() + self.value()
    }
}
impl<T: UnitValue> UnitExt for T {}
pub fn main() {
    let _x = 42;
    let _y = test().double_value();
}
fn test() -> impl UnitValue {
    100
}
trait NewTrait<const N: usize> {}

Meta

1a91028

Error output

bug.rs:9:6: error: the trait bound ‘i32: NewTrait’ is not satisfied [E0277]
    6 | trait UnitValue: NewTrait {
      |                          required by this bound in: UnitValue
......
    9 | impl UnitValue for i32 {
      |      ^~~~~~~~~
      |               the trait NewTrait is not implemented for i32
bug.rs:19:20: error: the trait bound ‘T: NewTrait’ is not satisfied [E0277]
    6 | trait UnitValue: NewTrait {
      |                          required by this bound in: UnitValue
......
   19 | impl<T: UnitValue> UnitExt for T {}
      |                    ^~~~~~~
      |                           the trait NewTrait is not implemented for T

Segmentation fault (core dumped)

[Jean-Christian-Cirstea]

I confirm this bug. From my initial findings, it looks like the compiler gets stuck in an infinite loop: Rust::Resolver::UnifyRules::Resolve() -> Rust::Resolver::expect_opaque() -> Rust::Resolver::UnifyRules::resolve_subtype(). After a few seconds, it enters Rust::Resolver::UnifyRules::go() which ultimately leads to a segmentation fault in _int_malloc().

A simpler example related to this bug:

#![feature(intrinsics, lang_items, no_core)]
#![no_core]

#[lang = "sized"]
pub trait Sized {}

#[lang = "copy"]
pub trait Copy {}

trait Marker {}

trait Value: Marker {}

fn test<T: Value>(x: T) -> T {
    T
}

pub fn main() {
    let _ = test(100);
}

The compiles crashes very fast using this example:

#0  Rust::TyTy::TyVar::TyVar (this=this@entry=0x7ffdd7e95038, ref=34) at ../../gcc/rust/typecheck/rust-tyty-util.cc:30
30	  auto context = Resolver::TypeCheckContext::get ();

The backtrace shows a very long recursion:

#853 0x00000000008f6d84 in Rust::TyTy::ParamType::get_name[abi:cxx11]() const (this=<optimized out>)
    at ../../gcc/rust/typecheck/rust-tyty.cc:3418

strace indicates:

--- SIGSEGV {si_signo=SIGSEGV, si_code=SEGV_MAPERR, si_addr=0x7fff41dffff8} ---
--- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=NULL} ---

Running gdb until the first SIGSEGV:

sp             0x7ffffbfff000      0x7ffffbfff000

I suspect a stack overflow caused by the infinite recursion. I'll dig later today into the problem. May I be assigned to this bug?

[Jean-Christian-Cirstea]

Further investigation: the problem doesn't seem related to unmet supertrait bound. If you remove the trait bound, the compiler still crashes. The following test functions do not crash the compiler:

fn test() -> impl UnitValue {
    100i32
}

fn test<T: UnitValue>() -> T {
    100
}

The problem seems to stem from position-return impls (OpaqueType in the source code). The compiler seems to get stuck in an infinite loop when trying to unify an unspecified integer type (<integer>) with an OpaqueType.

Unfortunately, I'm new to the gccrs project so I don't have a solution in mind right now.

[Jean-Christian-Cirstea]

The problem might be that during unification, Infer node is coerced to an Opaque node. I don't think this should happen.