Issue Description:

Consider the following simple code.

final class Test {
    private(set) var base: Int = 0
    func getBase() -> Int {
        return self.base
    }
}

When compiled, we get the following code for getBase and its callees:

_$s4test4TestC7getBaseSiyF:        // test.Test.getBase() -> Swift.Int
    push       rbp
    mov        rbp, rsp
    pop        rbp
    jmp        _$s4test4TestC4baseSivg      ; test.Test.base.getter : Swift.Int

_$s4test4TestC4baseSivg:        // test.Test.base.getter : Swift.Int
    push       rbp                          ; CODE XREF=_$s4test4TestC7getBaseSiyF+5
    mov        rbp, rsp
    sub        rsp, 0x20
    lea        rdi, qword [r13+0x10]
    lea        rsi, qword [rbp+var_18]
    xor        edx, edx
    xor        ecx, ecx
    call       imp___stubs__swift_beginAccess ; swift_beginAccess
    mov        rax, qword [r13+0x10]
    add        rsp, 0x20
    pop        rbp
    ret

Note that in this code path, we emit calls to swift_beginAccess in getBase.

If we change the above code to make var base private instead of private(set), we get new output for getBase:

_$s4test4TestC7getBaseSiyF:        // test.Test.getBase() -> Swift.Int
    push       rbp
    mov        rbp, rsp
    mov        rax, qword [r13+0x10]
    pop        rbp
    ret

Note that the call to swift_beginAccess is gone.

This optimisation implies that there exists an optimisation path that can audit all accesses to a class property and validate at compile time that it is not possible for this code to violate the law of exclusivity and so no runtime enforcement is required.

The issue here is that the same optimisation should apply to the first version of the code. Law of exclusivity violations require that at some point someone writes to this field. If they never do, we cannot violate it. Having a private setter makes that just as auditable in the first case as the second, however Swift fails to do it.

This optimisation would be very valuable. SwiftNIO's ByteBuffer emits significant beginAccess traffic in their code paths due to obtaining a single field off their base storage.