[SR-13746] Throwing initializers vs. deinit: breaking change in Swift 5.3.1

[groue]

Previous ID	SR-13746
Radar	rdar://problem/70379842
Original Reporter	@groue
Type	Bug
Status	Resolved
Resolution	Won't Do

Environment

Apple Swift version 5.3.1 (swiftlang-1200.0.41 clang-1200.0.32.8)

Xcode version 12.2 beta 3 (12B5035g)

macOS 10.15.6 (19G2021)

Additional Detail from JIRA

Votes	0
Component/s	Compiler
Labels	Bug
Assignee	None
Priority	Medium

md5: e915273ef3ea66ad1e41b2d1515cca89

Issue Description:

Hello, the compiler Apple Swift version 5.3.1 (swiftlang-1200.0.41 clang-1200.0.32.8) that ships with Xcode version 12.2 beta 3 (12B5035g) has introduced a breaking change.

The program below has changed its behavior. In previous Swift versions, the deinitializer would not run, and the program would print nothing. In Swift 5.3.1 / Xcode 12.2 beta 3, the deinitializer runs, and the program prints "deinit".

struct TestError: Error { }
class Inner {
    init() throws { }
}
class Test {
    private let inner: Inner
    init() throws {
        inner = try Inner()
        throw TestError()
    }
    deinit { print("deinit") }
}
do { _ = try Test() }
catch { }

I can not tell if this is an intended change, or not.

Still, this is a breaking change. It affects the GRDB library, because an error during the initialization of an SQLite database closes the connection twice on Xcode 12.2 beta 3, and this triggers an assertion failure. See https://github.com/groue/GRDB.swift/blob/v5.0.2/GRDB/Core/SerializedDatabase.swift#L17-L69

I do not know if I should adapt the program for this new behavior, or wait for this breaking change to be resolved. Any clue on this question would be appreciated!

Thank you

[groue]

This other program below makes me think that this breaking change is a bug fix, because it enhances the consistency of the language. It runs both deinitializers in Swift 5.3.1, but only runs the second one in previous Swift versions.

If it is actually the intent of the compiler team to preserve this new behavior, I would like to know how I can adapt the code so that it exhibits the same behavior across multiple compiler versions. Which `#if` should I use?

struct TestError: Error { }
class ThrowingInner {
    init() throws { }
}
class Inner {
    init() { }
}
class Test1 {
    private let inner: ThrowingInner
    init() throws {
        inner = try ThrowingInner()
        throw TestError()
    }
    deinit { print("deinit Test1") }
}
class Test2 {
    private let inner: Inner
    init() throws {
        inner = Inner()
        throw TestError()
    }
    deinit { print("deinit Test2") }
}

do { _ = try Test1() } catch { }
do { _ = try Test2() } catch { }

[typesanitizer]

Thanks for providing a minimal example.

@swift-ci create

[slavapestov]

This was an intentional change: #33734

The old behavior was inconsistent and an unintentional consequence of various implementation decisions.

The new behavior is simply that once all the stored properties of an instance are fully initialized, releasing the last reference to the instance calls deinit, regardless of whether it happens inside the constructor, or after the constructor, or as a result of throwing, etc.

My apologies for the unintended breakage though. Perhaps the most robust workaround to keep your code working with old and new Swift compiler versions is to make the close operation idempotent, for example by storing a flag indicating if its already been performed. Does that work for you?

[groue]

Thanks for expressing the intent, @slavapestov ... [Done)|groue/GRDB.swift#859]