Postcondition of std::lock and std::try_lock:

All of Mutexes... are locked, no deadlock occurs.

Effects: All arguments are locked via a sequence of calls to lock(), try_lock(), or unlock() on each argument.

The sequence of calls does not result in deadlock, but is otherwise unspecified.

But in an common case, when there is a type with a mutex and you need to swap it

void swap(Type& other) {
  std::scoped_lock l(this->mutex, other.mutex);
  // ... do swap ... 
}

If addressof(other) == this same mutex will be locked, and there are no precondition which blocks this usage.

But in fact its undefined behavior (implementation uses try_lock on already locked mutex) (deadlock on msvc-stl, just ub on others)

There are several solutions to this, either we explicitly add precondition, or the implementation must handle this (then there could potentially be an overhead when unlocking)