Fix Bugzilla 11725: AA.dup should return mutable AA where possible

Since the original AA has been duplicated, it should be safe to mutate
the copy. No need to restrict the copy to be const too.

druntime/src/object.d

@@ -3008,15 +3008,22 @@ T rehash(T : shared Value[Key], Value, Key)(T* aa)
  * Params:
  *      aa =     The associative array.
  */
-V[K] dup(T : V[K], K, V)(T aa)
+auto dup(T : V[K], K, V)(T aa)
 {
     //pragma(msg, "K = ", K, ", V = ", V);
 
     // Bug10720 - check whether V is copyable
     static assert(is(typeof({ V v = aa[K.init]; })),
         "cannot call " ~ T.stringof ~ ".dup because " ~ V.stringof ~ " is not copyable");
 
-    V[K] result;
+    // bug 11725: return mutable AA if possible
+    import core.internal.traits : Unconst;
+    static if (is(V : Unconst!V))
+        alias Result = Unconst!V[K];
+    else // mutable dup not possible, return const object instead.
+        alias Result = V[K];
+
+    Result result;
 
     //foreach (k, ref v; aa)
     //    result[k] = v;  // Bug13701 - won't work if V is not mutable
@@ -3046,7 +3053,7 @@ V[K] dup(T : V[K], K, V)(T aa)
 }
 
 /** ditto */
-V[K] dup(T : V[K], K, V)(T* aa)
+auto dup(T : V[K], K, V)(T* aa)
 {
     return (*aa).dup;
 }
@@ -3060,6 +3067,28 @@ V[K] dup(T : V[K], K, V)(T* aa)
     assert("k2" !in a2);
 }
 
+// bug 11725
+///
+@safe unittest
+{
+    const int[string] aa = ["a": 1, "b": 2];
+    // Copied AA values can be mutable
+    int[string] bb = aa.dup;
+    assert(bb == ["a": 1, "b": 2]);
+    assert(++bb["b"] == 3);
+}
+
+version (CoreUnittest)
+@safe test11725()
+{
+    // contra case of 11725: dup'ing an AA with elements that cannot convert to
+    // non-const should yield const AA instead.
+    class C { }
+    const C[string] aa = [ "a": new C ];
+    auto bb = aa.dup;
+    static assert(is(typeof(bb) == const(C)[string]));
+}
+
 // this should never be made public.
 private AARange _aaToRange(T: V[K], K, V)(ref T aa) pure nothrow @nogc @safe
 {