Assertion failed: "Ptr must be a pointer to Val type!"

[rozaliev]

rust version: rustc 0.12.0-pre-nightly (09abbbd 2014-09-11 00:05:41 +0000)

Assertion failed: (getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementType() && "Ptr must be a pointer to Val type!"), function AssertOK, file /Users/rustbuild/src/rust-buildbot/slave/nightly-mac/build/src/llvm/lib/IR/Instructions.cpp, line 1085.

code to reproduce:

trait Tr: Clone {
  fn clone_to_tobj(&self) -> Box<Tr> {
    return box self.clone()
  }
}

#[deriving(Clone)]
struct A;
impl Tr for A {
}


fn main() {
   let a: Box<Tr> = box A;
}

but this compiles fine

trait Tr: Clone {
  fn clone_to_tobj(&self) -> Box<Tr> {
    box self.clone()
  }
}

#[deriving(Clone)]
struct A;
impl Tr for A {
}


fn main() {
   let a: Box<Tr> = box A;
}

[retep998]

Ran into this assertion while compiling retep998/ftb-rs@27ce2aa on win64.

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
Assertion failed!

Program: A:\rust64\bin\rustc.exe
File: A:/msys64/home/retep998/rust/src/llvm/lib/IR/Instructions.cpp, Line 1085

Expression: getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementType() && "Ptr must be a pointer to Val type!"

[pnathan]

This will engender the bug as well:

fn read_file(path : String) -> Box<[u8]> {
    return box []
}


fn main() {
}

[mdup]

This example crashes on the same assert.

trait Vehicle { }
struct Car;
impl Vehicle for Car { }

fn build_car<'a>() -> Box<Vehicle + 'a> {
    loop {
        return box Car;
    }
}

fn main() { }

Interestingly, it does not fail to compile when return box Car; is moved out of the loop:

struct Car;
trait Vehicle { }
impl Vehicle for Car { }

fn build_car<'a>() -> Box<Vehicle + 'a> {
    return box Car;
}

fn main() { }

[wackywendell]

I also see this for this minimal version of this project. cargo build works fine, but cargo test has the same error.

[tomjakubowski]

Another (as minimal as I could get it) reproduction on rustc 0.13.0-dev (8d8f41b75 2014-11-29 21:51:34 +0000:

extern "C" fn foo(_: Blah) { }

struct Blah {
    _ptr: extern "C" fn(Blah)
}

fn main() {
    Blah { _ptr: foo };
}

rustc: /build/rust-git/src/rust/src/llvm/lib/IR/Instructions.cpp:1086: void llvm::StoreInst::AssertOK(): Assertion `getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementType() && "Ptr must be a pointer to Val type!"' failed.
Aborted (core dumped)

Note that there is no assertion failure without the extern "C".

[ftxqxd]

Another case that causes the same error (but for all I know could have a completely different cause):

struct Foo<Sized? T> {
    x: u8,
    y: T,
}

fn main() {
    let foo: &Foo<[int]> = &Foo { x: 1, y: [1i, 2, 3] };
    match *foo {
        Foo { x, ref y } => {},
    }
}

[tomassedovic]

Here's a shorter example for unboxed closures:

#![feature(unboxed_closures)]

fn main() {
    let i = 0i;
    let some_closure = |&: | {
        let _capture = i;
    };
}

Compiling with rustc --debuginfo 2 repro.rs:

rustc: /home/rustbuild/src/rust-buildbot/slave/nightly-linux/build/src/llvm/lib/IR/Instructions.cpp:1086: void llvm::StoreInst::AssertOK(): Assertion `getOperand(0)->getType() == cast<PointerType>(getOperand(1)->getType())->getElementType() && "Ptr must be a pointer to Val type!"' failed.
Aborted

If you specify --debuginfo 1 or no debuginfo at all, it compiles fine.

It also compiles correctly if don't capture anything from within the closure.

Reproduced on:

$ rustc --version verbose
rustc 0.13.0-nightly (5484d6f6d 2014-12-02 00:22:00 +0000)
binary: rustc
commit-hash: 5484d6f6d2844e9c52d42db52a1ba94739e10996
commit-date: 2014-12-02 00:22:00 +0000
host: x86_64-unknown-linux-gnu
release: 0.13.0-nightly

[hugwijst]

A few variations on the example from @mdup that do and don't compile.
TL;DR A workaround for this issue is to cast the box to the function return type, eg. box Car as Box<Vehicle>.

Implicit return: no failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    box Car
}

Explicit return, no closing semicolon: failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    return box Car
}

Explicit return, closing semicolon: no failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    return box Car;
}

Explicit return, cast, both closing and no closing semicolon: no failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    return box Car as Box<Vehicle>;
}

In loop, explicit return, both closing and no closing semicolon: failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    loop {
        return box Car;
    }
}

In loop, explicit return, cast, both closing and no closing semicolon: no failure

fn build_car<'a>() -> Box<Vehicle + 'a> {
    loop {
        return box Car as Box<Vehicle>;
    }
}