Compiler assertion failure with -O, zero-size struct, and NonCopyable

[MicahChalmer]

This program:

use std::util::NonCopyable;
struct Foo {
    nocopies: NonCopyable
}

fn make_foo() -> Foo {
    Foo { nocopies: NonCopyable::new() }
}

fn main() {
    let _f:Foo = make_foo();
}

will cause the compiler to crash and print this when compiled with -O:

Assertion failed: (begin() + idx < end()), function operator[], file /Users/micah/progs/rust/src/llvm/include/llvm/ADT/SmallVector.h, line 140.
Stack dump:
0.  Running pass 'Function Pass Manager' on module 'dag_dawg.rc'.
1.  Running pass 'X86 DAG->DAG Instruction Selection' on function '@_ZN4main19heaa017369cfad4b1ar4v0.0E'

(dag_dawg.rs was the file name I tried to compile.) Without -O it compiles fine. If you replace NonCopyable::new() with just NonCopyable it compiles fine, suggesting that NonCopyable::new() itself is no longer even necessary.

I created my own version of NonCopyable in another crate and linked to it. The crash reproduced only if, like std::NonCopyable, my struct had the attribute #[unsafe_no_drop_flag].

Add a non-zero-length field to the struct and the crash goes away.

[sanxiyn]

NonCopyable::new was removed in #10575. Can you provide a test case not depending on NonCopyable::new?

[MicahChalmer]

Yup, I can still reproduce it. You need two files for it. The first is a library crate, which compiles fine--let's call it issue10028.rs:

#[crate_type="lib"];

#[unsafe_no_drop_flag]
pub struct ZeroLengthThingWithDestructor;
impl Drop for ZeroLengthThingWithDestructor {
    fn drop(&mut self) {}
}
impl ZeroLengthThingWithDestructor {
    pub fn new() -> ZeroLengthThingWithDestructor {
        ZeroLengthThingWithDestructor
    }
}

The library crate compiles fine. Now try to compile this file that uses it with rustc -O (allowing it to find the library built from above) and you'll see the same ICE described above:

extern mod issue10028;
use issue10028::ZeroLengthThingWithDestructor;

struct Foo {
    zero_length_thing: ZeroLengthThingWithDestructor
}

fn make_foo() -> Foo {
    Foo { zero_length_thing: ZeroLengthThingWithDestructor::new() }
}

fn main() {
    let _f:Foo = make_foo();
}

This is basically the same test case I had before--I just replaced NonCopyable with another struct that is the same as the old NonCopyable before the new method was eliminated.

If you combine them into the same crate (even issue10028.rs is still its own file as a module) then the problem does not occur. It has to be in a separate crate from the one being compiled.

[alexcrichton]

This has been fixed, flagging as needstest