8d27232141
This patch primarily does two things: (1) it prevents lifetimes from
leaking out of unboxed closures; (2) it allows unboxed closure type
notation, call notation, and construction notation to construct closures
matching any of the three traits.
This breaks code that looked like:
let mut f;
{
let x = &5i;
f = |&mut:| *x + 10;
}
Change this code to avoid having a reference escape. For example:
{
let x = &5i;
let mut f; // <-- move here to avoid dangling reference
f = |&mut:| *x + 10;
}
I believe this is enough to consider unboxed closures essentially
implemented. Further issues (for example, higher-rank lifetimes) should
be filed as followups.
Closes #14449.
[breaking-change]
128 lines
2.5 KiB
Rust
128 lines
2.5 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
// A battery of tests to ensure destructors of unboxed closure environments
|
|
// run at the right times.
|
|
|
|
#![feature(overloaded_calls, unboxed_closures)]
|
|
|
|
static mut DROP_COUNT: uint = 0;
|
|
|
|
fn drop_count() -> uint {
|
|
unsafe {
|
|
DROP_COUNT
|
|
}
|
|
}
|
|
|
|
struct Droppable {
|
|
x: int,
|
|
}
|
|
|
|
impl Droppable {
|
|
fn new() -> Droppable {
|
|
Droppable {
|
|
x: 1
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Drop for Droppable {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
DROP_COUNT += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
fn a<F:|&: int, int| -> int>(f: F) -> int {
|
|
f(1, 2)
|
|
}
|
|
|
|
fn b<F:|&mut: int, int| -> int>(mut f: F) -> int {
|
|
f(3, 4)
|
|
}
|
|
|
|
fn c<F:|: int, int| -> int>(f: F) -> int {
|
|
f(5, 6)
|
|
}
|
|
|
|
fn test_fn() {
|
|
{
|
|
a(|&: a: int, b| { a + b });
|
|
}
|
|
assert_eq!(drop_count(), 0);
|
|
|
|
{
|
|
let z = &Droppable::new();
|
|
a(|&: a: int, b| { z; a + b });
|
|
assert_eq!(drop_count(), 0);
|
|
}
|
|
assert_eq!(drop_count(), 1);
|
|
|
|
{
|
|
let z = &Droppable::new();
|
|
let zz = &Droppable::new();
|
|
a(|&: a: int, b| { z; zz; a + b });
|
|
assert_eq!(drop_count(), 1);
|
|
}
|
|
assert_eq!(drop_count(), 3);
|
|
}
|
|
|
|
fn test_fn_mut() {
|
|
{
|
|
b(|&mut: a: int, b| { a + b });
|
|
}
|
|
assert_eq!(drop_count(), 3);
|
|
|
|
{
|
|
let z = &Droppable::new();
|
|
b(|&mut: a: int, b| { z; a + b });
|
|
assert_eq!(drop_count(), 3);
|
|
}
|
|
assert_eq!(drop_count(), 4);
|
|
|
|
{
|
|
let z = &Droppable::new();
|
|
let zz = &Droppable::new();
|
|
b(|&mut: a: int, b| { z; zz; a + b });
|
|
assert_eq!(drop_count(), 4);
|
|
}
|
|
assert_eq!(drop_count(), 6);
|
|
}
|
|
|
|
fn test_fn_once() {
|
|
{
|
|
c(|: a: int, b| { a + b });
|
|
}
|
|
assert_eq!(drop_count(), 6);
|
|
|
|
{
|
|
let z = Droppable::new();
|
|
c(|: a: int, b| { z; a + b });
|
|
assert_eq!(drop_count(), 7);
|
|
}
|
|
assert_eq!(drop_count(), 7);
|
|
|
|
{
|
|
let z = Droppable::new();
|
|
let zz = Droppable::new();
|
|
c(|: a: int, b| { z; zz; a + b });
|
|
assert_eq!(drop_count(), 9);
|
|
}
|
|
assert_eq!(drop_count(), 9);
|
|
}
|
|
|
|
fn main() {
|
|
test_fn();
|
|
test_fn_mut();
|
|
test_fn_once();
|
|
}
|
|
|