There is an unsaved comment in progress. You will lose your changes if you continue. Are you sure you want to reopen the work item?
A common idiom is to take a wrapped object, temporarily pass ownership to some data structure, and take ownership back before returning. Two common examples are (1) where ownership has to be temporarily passed to another thread, and (2) where you want to wrap the object inside of some other object for the purpose of enforcing an invariant on it. The important thing is that there is no reason to notify the caller that ownership temporarily transferred, so there is no reason to put it into a writes clause.
One way to do this without making verification any harder for legacy code is to force the user to say that he is "borrowing" an object, with the obligation of giving it back. This is like a writes clause, but (0) the precondition it takes is that the object is wrapped, (1) only the owner of an object can be changed - it can't be opened up, and (2) there is an implicit postcondition that the owner is unchanged (i.e., it has the same owner at the end as at the beginning). The important difference is that a block can borrow an object without the containing block borrowing or writing it.
Note that we have a similar situation wrt claims on an subject, i.e. taking out temporary claims on an subject requires writing it. However, in this case, we would have a workaround, namely creating a temporary wrapper object to own the subject and claiming the wrapper.