Okay I think I explained myself poorly.
What I meant is, when using methods of some struct, some of which have
&self and some of which have
&mut self as a receiver (and respectively return
&mut borrows), even with NLL I can't use them in any old random order in some fn/method using them. And that's even when the
&self methods access completely different fields of
Self than the
&mut self methods do i.e. the set of fields accessed by the
&self method is disjoint from the set of fields accessed by
&mut self method.
This invites a question of course: why not split
Self into multiple types? The answer is that conceptually that information belongs together and splitting up the types would make the code not more readable, but less.
In fact it would be so much less readable that it makes a couple of unsafe usages look hackish-but-workable, rather than "In this code base? Never!".
This in turn leads me to shutting up
borrowck a couple of times in the code by casting the (mutable) borrows to (mutable) raw ptrs and back again within an
unsafe block. NLL has made a difference here, since I could remove a couple of instances of this unsafe code. But NLL didn't eliminate the need for it.