closure in record triggers a memory leak and abort

[erickt]

There seems to be an issue with closures in records and the type checker. This code segfaults with a leaked memory message:

type t<T> = { f: fn() -> T };

fn f<T>(_x: t<T>) {}

fn main() {
    let x: t<()> = { f: { || () } };
    f(x);
}

However, if you remove : t<()> from let x: t<()> = { f: { || () } };, it works just fine.

[nikomatsakis]

I am running into some leaks myself which look similar. I will assign to myself and hope that fixing my problems will fix this one too.

[nikomatsakis]

Actually, I am not able to reproduce this problem.

[brson]

I do see it. Really surprising.

[brson]

When you rewrite it like this (with fn@) it works:

type t<T> = { f: fn@() -> T };                                                                                                                                                

fn f<T>(_x: t<T>) {}                                                                                                                                                          

fn main() {                                                                                                                                                                   
    let x: t<()> = { f: { || () } };                                                                                                                                          
    f(x);                                                                                                                                                                     
}      

I'm not actually sure what fn means in this record.

[nikomatsakis]

So, it would not be possible to store an fn& into the record... the type of the record says that it contains some kind of closure. Our restrictions on fn& should ensure that this closure is either an fn@ or fn~. The closure kind inferencer will pick @ in the absence of any other good choice, so {f: {|| ()}} should have the type {f: fn@() -> ()}.

[nikomatsakis]

Revisiting this, it's clear why there is a leak: an fn() type should not appear in a record. The drop glue will take no action.

[catamorphism]

This issue appears to be fixed: the typechecker now rejects this program. Added it as a test case in 2a53640 .

[catamorphism]

Another test case:

use std;

type boxedFn = { theFn: fn () -> uint };

fn createClosure (closedUint: uint) -> boxedFn {
    { theFn: fn@ () -> uint { closedUint } }
}

#[test]
fn testForLeakage () {
    let aFn: boxedFn = createClosure(10);

    let myInt: uint = aFn.theFn();

    assert myInt == 10;
}

[nikomatsakis]

I think this will get fixed as part of the regions work on fns I need to do.

[nikomatsakis]

#2202 specifically.

[bblum]

This also leaks; is it the same issue?

fn zipWith<A:copy,B:copy,C>(f: fn@((A,B))->C) -> fn(+~[A]) -> fn(+~[B]) -> ~[C] {
    fn@(+a: ~[A]) -> fn(+b: ~[B]) -> ~[C] {
        fn@(+b: ~[B], move a) -> ~[C] {
            vec::zip(a,b).map(f)
        }
    }
}

fn sum(x: (int,int)) -> int { let (y,z) = x; y+z }

fn main() {
    for zipWith(sum)(~[1,2,3,4])(~[10,20,30,40]).each |i| {
        io::println(#fmt("%d", i));
    }
}

It prints 11, 22, 33, 44, then proclaims:

Unreclaimed object found at 0x7fe6241009a0: (~[1, 2, 3, 4], fn)
Unreclaimed object found at 0x7fe624100900: (fn)
leaked memory in rust main loop (2 objects)

[nikomatsakis]

same issue.