Empty struct lifetime bug

[angdev]

I asked stackoverflow about lifetime of variable. Original link is this : http://stackoverflow.com/questions/21226942/rust-lifetime-and-calling-member-function

** Question from link **

I have a question about lifetime of varable in Rust programming language.

createTest function creates and returns r-value reference. and when it returns a reference, testValue is destroyed. But test.print() doesn't lead to crash. Why?

(Is Test::print function called as static function?)

Code

struct Test;                                                         
impl Drop for Test {                                                       
  fn drop (&mut self) {                                                    
    println("Dropped.");                                                   
  }                                                                        
}                                                                          

impl Test {                                                                
  fn print(&self) { println!("Print!"); }                                  
}                                                                          

fn createTest() -> &Test {                                                 
  let testValue = &Test;                                                   
  return testValue;                                                        
}                                                                          

fn main() {                                                                
  let test = createTest();                                             
  test.print();                                                            
  println("Test");                                                         
}

Result

Dropped.
Print!
Test

It happened with empty struct only. Is it a really bug?

[huonw]

Thanks for the report! I'm closing this as a dupe of #8309 and #10800: the latter means that testValue is of type &'static Test, and the former means that it is legal to return this via an anonymous lifetime.

[huonw]

Oh, my apologies, I missed the Drop implementation. This does seem like a bug with how Drop interacts with those two bugs I referenced above.

[alexcrichton]

Nominating, this sounds bad.

[pnkfelix]

Accepted for 1.0, P-backcompat-lang.

Also, cc @nikomatsakis

[flaper87]

I'm digging into this. @nikomatsakis if you've any pointers that would help debugging the issue, please let me know 😄

[flaper87]

I dug a bit into this. If what I looked into is correct, testValue is being treated as a static item instead of being treated as an rvalue given the fact that it's no-Pod. This doesn't seem wrong for PODs but it should be for non-PODs.

This is the borrowck log for the &Test section:

add_assignment[var](lp=$(local (id=97, name=testValue)), assignment=0, path_index=middle::borrowck::move_data::MovePathIndex(0u))
gather_loans_in_expr(expr=99u32/&Test)
guarantee_valid(borrow_id=99u32, cmt={cat_static_item id:98 m:McImmutable ty:Test}, req_mutbl=ImmutableMutability, loan_region=ReFree(middle::ty::FreeRegion{scope_id: 103u32, bound_region: BrAnon(0u)}))
guarantee_lifetime(cmt={cat_static_item id:98 m:McImmutable ty:Test}, loan_region=ReFree(103, BrAnon(0)))
guarantee_lifetime.check(cmt={cat_static_item id:98 m:McImmutable ty:Test}, loan_region=ReFree(103, BrAnon(0)))

[nikomatsakis]

@flaper87 you are correct, and it's just wrong all the time. We should treat unary structs and nullary enum variants as rvalues, not static items.

[flaper87]

@nikomatsakis r?