Self-move-assign of array nullifies the storage while keeping the shape the same

[Wentzell]

This is to keep track of an open discussion as to how we want to handle self-move-assignment for basic_array.

basic_array<double, 1> A(3);
A() = 9;
A = std::move(A);

This calls the defaulted move-assignment

basic_array &operator=(basic_array &&x) = default;

which will trigger a stack-copy of the shape (idx_map), while nullifying the storage (handle). C.f.

    handle_heap &operator=(handle_heap &&x) noexcept {
      if (not sptr and not(is_null())) destruct({_data, _size});
      _data   = x._data;
      _size   = x._size;
      sptr    = std::move(x.sptr);
      x._data = nullptr;
      x._size = 0;
      return *this;
    }

In other words the array ends up with null-storage and non-zero shape.
Do we want to protect the handle move-assign for this == &x ?

C.f. also https://ericniebler.com/2017/03/31/post-conditions-on-self-move/

[parcollet]

It indeed leaves the array "in a valid but unspecified state"..., in fact in a simple state...
We don't have to protect it I think.
But we could add an assert in handle_heap this !=x in debug mode (NDA_DEBuG) ?