Fix Issue 18913 - Cannot move static array of non-copyable type

[edi33416]

No description provided.

[dlang-bot]

Thanks for your pull request and interest in making D better, @edi33416! We are looking forward to reviewing it, and you should be hearing from a maintainer soon.
Please verify that your PR follows this checklist:

• My PR is fully covered with tests (you can see the annotated coverage diff directly on GitHub with CodeCov's browser extension
• My PR is as minimal as possible (smaller, focused PRs are easier to review than big ones)
• I have provided a detailed rationale explaining my changes
• New or modified functions have Ddoc comments (with Params: and Returns:)

Please see CONTRIBUTING.md for more information.

---

If you have addressed all reviews or aren't sure how to proceed, don't hesitate to ping us with a simple comment.

Bugzilla references

Auto-close	Bugzilla	Severity	Description
✓	18913	major	Cannot move static array of non-copyable type

Testing this PR locally

If you don't have a local development environment setup, you can use Digger to test this PR:

dub fetch digger
dub run digger -- build "master + phobos#6810"

[edi33416]

While working at this, I've noticed that move doesn't nullify references.
This, imho, is a big issue. See code snippet

@safe
void main()
{
  int[] x = [1, 2, 3];
  int[] nx;

  move(x, nx); // nx should take ownership, but it just points to the same address
  
  assert(x == nx); // oho
  x[0] = 2; // should fail, but, instead, it silently modifies nx's content
  assert(nx == [1, 2, 3]); // fails because of bug
}

[PetarKirov]

I would write the whole thing as:

static if (is(T == struct))
{
    // ...
}
else static if (isStaticArray!T)
    moveEmplaceAll(source[], target[]);
else
    target = source;

[edi33416]

Moved the code inside else static if.

Can't use moveEmplaceAll as source[] fails the isInputRange check

[PetarKirov]

Yes, unfortunately the isInputRange constraint is too strict for move[Emplace]{All|Some} functions, as a range, whose elements are not copy-able is the primary use-case for move-ing.

If we adjust isInputRange like so

@@ -168,7 +168,10 @@
 enum bool isInputRange(R) =
     is(typeof(R.init) == R)
     && is(ReturnType!((R r) => r.empty) == bool)
-    && is(typeof((return ref R r) => r.front))
+    && (
+            is(typeof((return ref R r) => r.front)) ||
+            is(typeof((return ref R r) => &r.front()))
+       )
     && !is(ReturnType!((R r) => r.front) == void)
     && is(typeof((R r) => r.popFront));

all tests pass.

[PetarKirov]

Looks good, we can revisit the IsInputRange question in the future.