duplicates:

• SR-2773 function abnormally releasing instance.

Issue Description:

Details

Consider the following function, taking a subject and modifying it in place using a provided closure:

func modify<T>(_ subject: T, _ closure: (inout T) -> Void) -> T {
    var subject = subject
    closure(&subject)
    return subject
}

Then, consider the following code that uses that function:

class Foo {
    var bar: Int = 1
}

let a = modify(Foo()) { (i: inout Foo) in
    i.bar = 2
}

The value of a.bar in the above example is 2, as expected.

However, after removing (i: inout Foo) in, which should be inferred by the compiler, the following code successfully compiles and crashes at runtime with a memory corruption error:

let b = with(Foo()) {
    $0.bar = 2
}

*** error for object 0x608000030a04: Invalid pointer dequeued from free list
*** set a breakpoint in malloc_error_break to debug

Workarounds

The following special overload of modify function produces the expected result with the same test code (b) as above:

func modify<T: AnyObject>(_ subject: T, _ closure: (T) -> Void) -> T {
    closure(subject)
    return subject
}

let b = modify(Foo()) {
    $0.bar = 2
}

The value of b.bar in this case is 2, as expected.

Possibly connected issue

The above bug seems connected with the requirement to explicitly write (foo: inout Bar) in every time a closure mutates something in place, no matter if it's a struct or a class. This is not the expected behavior, though, as the compiler should automatically infer (from the closure's type) that the parameter is inout.