Merge pull request #2337 from n8sh/issue-19332

hashOf fails to compile for const struct that has non-const toHash & has all fields bitwise-hashable
merged-on-behalf-of: Nathan Sashihara <n8sh@users.noreply.github.com>

Author: dlang-bot

src/core/internal/hash.d

@@ -10,7 +10,7 @@
 module core.internal.hash;
 
 import core.internal.convert;
-import core.internal.traits : allSatisfy;
+import core.internal.traits : allSatisfy, Unconst;
 
 // If true ensure that positive zero and negative zero have the same hash.
 // Historically typeid(float).getHash did this but hashOf(float) did not.
@@ -506,7 +506,7 @@ private enum _hashOfStruct =
 q{
     enum bool isChained = is(typeof(seed) : size_t);
     static if (!isChained) enum size_t seed = 0;
-    static if (hasCallableToHash!T) //CTFE depends on toHash()
+    static if (hasCallableToHash!(typeof(val))) //CTFE depends on toHash()
     {
         static if (isChained)
             return hashOf(cast(size_t) val.toHash(), seed);
@@ -517,7 +517,15 @@ q{
     {
         static if (__traits(hasMember, T, "toHash") && is(typeof(T.toHash) == function))
         {
-            pragma(msg, "Warning: struct "~__traits(identifier, T)~" has method toHash, however it cannot be called with "~T.stringof~" this.");
+            // TODO: in the future maybe this should be changed to a static
+            // assert(0), because if there's a `toHash` the programmer probably
+            // expected it to be called and a compilation failure here will
+            // expose a bug in his code.
+            //   In the future we also might want to disallow non-const toHash
+            // altogether.
+            pragma(msg, "Warning: struct "~__traits(identifier, T)
+                ~" has method toHash, however it cannot be called with "
+                ~typeof(val).stringof~" this.");
         }
 
         static if (T.tupleof.length == 0)
@@ -553,6 +561,7 @@ q{
 //struct or union hash
 size_t hashOf(T)(scope const auto ref T val, size_t seed = 0)
 if (!is(T == enum) && (is(T == struct) || is(T == union))
+    && !is(T == const) && !is(T == immutable)
     && canBitwiseHash!T)
 {
     mixin(_hashOfStruct);
@@ -574,6 +583,15 @@ if (!is(T == enum) && (is(T == struct) || is(T == union))
     mixin(_hashOfStruct);
 }
 
+//struct or union hash - https://issues.dlang.org/show_bug.cgi?id=19332 (support might be removed in future)
+size_t hashOf(T)(scope auto ref T val, size_t seed = 0)
+if (!is(T == enum) && (is(T == struct) || is(T == union))
+    && (is(T == const) || is(T == immutable))
+    && canBitwiseHash!T && !canBitwiseHash!(Unconst!T))
+{
+    mixin(_hashOfStruct);
+}
+
 //delegate hash. CTFE unsupported
 @trusted @nogc nothrow pure
 size_t hashOf(T)(scope const T val, size_t seed = 0) if (!is(T == enum) && is(T == delegate))

test/hash/src/test_hash.d

@@ -9,6 +9,7 @@ void main()
     issue19204();
     issue19262();
     issue19282();
+    issue19332(); // Support might be removed in the future!
     testTypeInfoArrayGetHash1();
     testTypeInfoArrayGetHash2();
     pr2243();
@@ -135,6 +136,20 @@ void issue19282()
     h = hashOf(c, h);
 }
 
+/// Ensure hashOf works for const struct that has non-const toHash & has all
+/// fields bitwise-hashable. (Support might be removed in the future!)
+void issue19332()
+{
+    static struct HasNonConstToHash
+    {
+        int a;
+        size_t toHash() { return a; }
+    }
+    const HasNonConstToHash val;
+    size_t h = hashOf(val);
+    h = hashOf!(const HasNonConstToHash)(val); // Ensure doesn't match more than one overload.
+}
+
 /// Tests ensure TypeInfo_Array.getHash uses element hash functions instead
 /// of hashing array data.
 void testTypeInfoArrayGetHash1()