Compilation never finishes

[XopheD]

Project files (MCVE): bugreport.zip

Meta

rustc --version --verbose:

rustc 1.45.0 (5c1f21c3b 2020-07-13)
binary: rustc
commit-hash: 5c1f21c3b82297671ad3ae1e8c942d2ca92e84f2
commit-date: 2020-07-13
host: x86_64-apple-darwin
release: 1.45.0
LLVM version: 10.0

Error description

In fact there is no visible error but the compilation never finishes in release mode
(also with the nightly channel).

cargo build runs fine.

cargo build --release seems to fall in an infinite loop.

Note: if I associated the release mode with -O2, it works (that’s my current workaround).

Additional notes

When I try to make this example as small as possible, I notice that (refer to the joined files):

• if I move the contents of logic/for_each.rs directly inside logic.rs, it works
• if I suppress some alternatives in the enum ExprContents, it works too

[XopheD]

The minimal example is available in the joined files (bugreport.zip)
I guess that it is verifiable on other machine than mine

[eggyal]

I don't think it's hanging, just extremely slow due to an exponential explosion in the thin LTO pass (perhaps it's attempting to recursively inline the visitor implementation functions?). I've reduced the example to the following, which I'm sure can be minimized further:

mod logic {
    pub struct Expr(std::rc::Rc<ExprContent>);
    
    enum ExprContent {
        A(Vec<Expr>),
        B(Vec<Expr>),
        C(Vec<Expr>),
        D(Vec<Expr>),
        E(Vec<Expr>),
        F(Vec<Expr>),
        G(Vec<Expr>),
    }
    
    pub trait ExprVisitor {
        fn a(&self, e: &[Expr]);
        fn b(&self, e: &[Expr]);
        fn c(&self, e: &[Expr]);
        fn d(&self, e: &[Expr]);
        fn e(&self, e: &[Expr]);
        fn f(&self, e: &[Expr]);
        fn g(&self, e: &[Expr]);
    }
    
    impl Expr {
        pub fn new() -> Expr {
            unimplemented!()
        }
        
        pub fn accept_visitor(&self, visitor: &dyn ExprVisitor) {
            match & *self.0 {
                ExprContent::A(e) => visitor.a(&e),
                ExprContent::B(e) => visitor.b(&e),
                ExprContent::C(e) => visitor.c(&e),
                ExprContent::D(e) => visitor.d(&e),
                ExprContent::E(e) => visitor.e(&e),
                ExprContent::F(e) => visitor.f(&e),
                ExprContent::G(e) => visitor.g(&e),
            }
        }
    }

    mod for_each {
        use super::{Expr, ExprVisitor};

        struct ForEach;
        
        impl Expr {
            pub fn for_each(&self) {
                self.accept_visitor(&ForEach)
            }
        }
        
        impl ExprVisitor for ForEach {
            fn a(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }
            
            fn b(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }
        
            fn c(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }
        
            fn d(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }

            fn e(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }

            fn f(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }

            fn g(&self, e: &[Expr]) {
                e.iter().for_each(|x| x.accept_visitor(self))
            }
        }
    }
}

fn main() {
    let expr = logic::Expr::new();
    expr.for_each();
}

[Dylan-DPC]

@XopheD are you still facing this issue?

[XopheD]

No, I cut off some inline to avoid it

[Noratrieb]

I am not able to reproduce the issue, building it with thin lto only takes 2.63s which sounds totally fine.

[XopheD]

Thanks for your comment, and I agree with you: it seems that more recent versions of rustc deal better with this situation.
May Rust be with you.