search

vincenthz / hs-cryptohash

efficient and practical cryptohashing in haskell. DEPRECATED in favor of cryptonite
Other
30 stars 24 forks source link

cryptohash-0.11.7 fails to build with GHC 9.2 #45

Closed sjakobi closed 2 years ago

sjakobi commented 2 years ago 
Crypto/Hash/MD2.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD2.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD2.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD2.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD2.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 3 of 23] Compiling Crypto.Hash.MD4  ( Crypto/Hash/MD4.hs, dist/build/Crypto/Hash/MD4.o, dist/build/Crypto/Hash/MD4.dyn_o )

Crypto/Hash/MD4.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD4.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD4.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD4.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD4.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 4 of 23] Compiling Crypto.Hash.MD5  ( Crypto/Hash/MD5.hs, dist/build/Crypto/Hash/MD5.o, dist/build/Crypto/Hash/MD5.dyn_o )

Crypto/Hash/MD5.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD5.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD5.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD5.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/MD5.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 5 of 23] Compiling Crypto.Hash.RIPEMD160 ( Crypto/Hash/RIPEMD160.hs, dist/build/Crypto/Hash/RIPEMD160.o, dist/build/Crypto/Hash/RIPEMD160.dyn_o )

Crypto/Hash/RIPEMD160.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/RIPEMD160.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/RIPEMD160.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/RIPEMD160.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/RIPEMD160.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 6 of 23] Compiling Crypto.Hash.SHA1 ( Crypto/Hash/SHA1.hs, dist/build/Crypto/Hash/SHA1.o, dist/build/Crypto/Hash/SHA1.dyn_o )

Crypto/Hash/SHA1.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA1.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA1.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA1.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA1.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 7 of 23] Compiling Crypto.Hash.SHA224 ( Crypto/Hash/SHA224.hs, dist/build/Crypto/Hash/SHA224.o, dist/build/Crypto/Hash/SHA224.dyn_o )

Crypto/Hash/SHA224.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA224.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA224.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA224.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA224.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 8 of 23] Compiling Crypto.Hash.SHA256 ( Crypto/Hash/SHA256.hs, dist/build/Crypto/Hash/SHA256.o, dist/build/Crypto/Hash/SHA256.dyn_o )

Crypto/Hash/SHA256.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA256.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[ 9 of 23] Compiling Crypto.Hash.SHA3 ( Crypto/Hash/SHA3.hs, dist/build/Crypto/Hash/SHA3.o, dist/build/Crypto/Hash/SHA3.dyn_o )

Crypto/Hash/SHA3.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b i. finalize (foldl update (init i) b) = hashlazy i (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA3.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA3.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA3.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[10 of 23] Compiling Crypto.Hash.SHA384 ( Crypto/Hash/SHA384.hs, dist/build/Crypto/Hash/SHA384.o, dist/build/Crypto/Hash/SHA384.dyn_o )

Crypto/Hash/SHA384.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA384.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA384.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA384.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA384.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[11 of 23] Compiling Crypto.Hash.SHA512 ( Crypto/Hash/SHA512.hs, dist/build/Crypto/Hash/SHA512.o, dist/build/Crypto/Hash/SHA512.dyn_o )

Crypto/Hash/SHA512.hs:51:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
51 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA512.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA512.hs:55:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
55 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA512.hs:55:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
55 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/SHA512.hs:55:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
55 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[12 of 23] Compiling Crypto.Hash.SHA512t ( Crypto/Hash/SHA512t.hs, dist/build/Crypto/Hash/SHA512t.o, dist/build/Crypto/Hash/SHA512t.dyn_o )

on the commandline: warning: [-Wtrustworthy-safe]
    ‘Crypto.Hash.SHA512t’ is marked as Trustworthy but has been inferred as safe!
[13 of 23] Compiling Crypto.Hash.Skein256 ( Crypto/Hash/Skein256.hs, dist/build/Crypto/Hash/Skein256.o, dist/build/Crypto/Hash/Skein256.dyn_o )

Crypto/Hash/Skein256.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b i. finalize (foldl update (init i) b) = hashlazy i (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein256.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[14 of 23] Compiling Crypto.Hash.Skein512 ( Crypto/Hash/Skein512.hs, dist/build/Crypto/Hash/Skein512.o, dist/build/Crypto/Hash/Skein512.dyn_o )

Crypto/Hash/Skein512.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b i. finalize (foldl update (init i) b) = hashlazy i (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein512.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein512.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Skein512.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b i. finalize (foldl update (init i) $ L.toChunks b) = hashlazy i b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[15 of 23] Compiling Crypto.Hash.Tiger ( Crypto/Hash/Tiger.hs, dist/build/Crypto/Hash/Tiger.o, dist/build/Crypto/Hash/Tiger.dyn_o )

Crypto/Hash/Tiger.hs:50:11: warning: [-Winline-rule-shadowing]
    Rule "digestSize" may never fire
      because ‘B.length’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘B.length’
   |
50 | {-# RULES "digestSize" B.length (finalize init) = digestSize #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Tiger.hs:53:11: warning: [-Winline-rule-shadowing]
    Rule "hashmany" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
53 | {-# RULES "hashmany" forall b. finalize (foldl update init b) = hashlazy (L.fromChunks b) #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Tiger.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because ‘L.toChunks’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘L.toChunks’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Tiger.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire
      because rule "Class op foldl" for ‘foldl’ might fire first
    Probable fix: add phase [n] or [~n] to the competing rule
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Tiger.hs:54:11: warning: [-Winline-rule-shadowing]
    Rule "hashlazy" may never fire because ‘$’ might inline first
    Probable fix: add an INLINE[n] or NOINLINE[n] pragma for ‘$’
   |
54 | {-# RULES "hashlazy" forall b. finalize (foldl update init $ L.toChunks b) = hashlazy b #-}
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[16 of 23] Compiling Crypto.Hash.Utils.Cpu ( Crypto/Hash/Utils/Cpu.hs, dist/build/Crypto/Hash/Utils/Cpu.o, dist/build/Crypto/Hash/Utils/Cpu.dyn_o )

on the commandline: warning: [-Wtrustworthy-safe]
    ‘Crypto.Hash.Utils.Cpu’ is marked as Trustworthy but has been inferred as safe!
[17 of 23] Compiling Crypto.Hash.Utils ( Crypto/Hash/Utils.hs, dist/build/Crypto/Hash/Utils.o, dist/build/Crypto/Hash/Utils.dyn_o )

Crypto/Hash/Utils.hs:51:40: error:
    • Couldn't match expected type ‘Word32#’ with actual type ‘Word#’
    • In the first argument of ‘W32#’, namely
        ‘(or# (or# (or# hi2 lo2) hi1) lo1)’
      In the expression: W32# (or# (or# (or# hi2 lo2) hi1) lo1)
      In an equation for ‘to32’:
          to32 (I# i1) (I# i2)
            = W32# (or# (or# (or# hi2 lo2) hi1) lo1)
            where
                hi2 = uncheckedShiftL# (indexWord8OffAddr# tableLo i2) 24#
                lo2 = uncheckedShiftL# (indexWord8OffAddr# tableHi i2) 16#
                hi1 = uncheckedShiftL# (indexWord8OffAddr# tableLo i1) 8#
                lo1 = indexWord8OffAddr# tableHi i1
   |
51 |           to32 (I# i1) (I# i2) = W32# (or# (or# (or# hi2 lo2) hi1) lo1)
   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Utils.hs:51:68: error:
    • Couldn't match expected type ‘Word#’ with actual type ‘Word8#’
    • In the second argument of ‘or#’, namely ‘lo1’
      In the first argument of ‘W32#’, namely
        ‘(or# (or# (or# hi2 lo2) hi1) lo1)’
      In the expression: W32# (or# (or# (or# hi2 lo2) hi1) lo1)
   |
51 |           to32 (I# i1) (I# i2) = W32# (or# (or# (or# hi2 lo2) hi1) lo1)
   |                                                                    ^^^

Crypto/Hash/Utils.hs:52:43: error:
    • Couldn't match expected type ‘Word#’ with actual type ‘Word8#’
    • In the first argument of ‘uncheckedShiftL#’, namely
        ‘(indexWord8OffAddr# tableLo i2)’
      In the expression:
        uncheckedShiftL# (indexWord8OffAddr# tableLo i2) 24#
      In an equation for ‘hi2’:
          hi2 = uncheckedShiftL# (indexWord8OffAddr# tableLo i2) 24#
   |
52 |             where hi2 = uncheckedShiftL# (indexWord8OffAddr# tableLo i2) 24#
   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Utils.hs:53:43: error:
    • Couldn't match expected type ‘Word#’ with actual type ‘Word8#’
    • In the first argument of ‘uncheckedShiftL#’, namely
        ‘(indexWord8OffAddr# tableHi i2)’
      In the expression:
        uncheckedShiftL# (indexWord8OffAddr# tableHi i2) 16#
      In an equation for ‘lo2’:
          lo2 = uncheckedShiftL# (indexWord8OffAddr# tableHi i2) 16#
   |
53 |                   lo2 = uncheckedShiftL# (indexWord8OffAddr# tableHi i2) 16#
   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Crypto/Hash/Utils.hs:54:43: error:
    • Couldn't match expected type ‘Word#’ with actual type ‘Word8#’
    • In the first argument of ‘uncheckedShiftL#’, namely
        ‘(indexWord8OffAddr# tableLo i1)’
      In the expression:
        uncheckedShiftL# (indexWord8OffAddr# tableLo i1) 8#
      In an equation for ‘hi1’:
          hi1 = uncheckedShiftL# (indexWord8OffAddr# tableLo i1) 8#
   |
54 |                   hi1 = uncheckedShiftL# (indexWord8OffAddr# tableLo i1) 8#
   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
cabal: Failed to build cryptohash-0.11.7.
sjakobi commented 2 years ago

As a Hackage trustee I have revised this version to prevent build attempts with GHC 9.2: https://hackage.haskell.org/package/cryptohash-0.11.7/revisions/

sjakobi commented 2 years ago

I have revised v0.8.2 and up to v0.10.8 similarly.