extend/narrow primops were renamed

Data/Text/Internal/Encoding/Utf16.hs

@@ -1,4 +1,6 @@
-{-# LANGUAGE MagicHash, BangPatterns, CPP #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE BangPatterns #-}
 
 -- |
 -- Module      : Data.Text.Internal.Encoding.Utf16
@@ -23,22 +25,19 @@ module Data.Text.Internal.Encoding.Utf16
     , validate2
     ) where
 
-import GHC.Word (Word16(..))
-#if MIN_VERSION_base(4,16,0)
 import GHC.Exts
-#else
-import GHC.Exts hiding (extendWord16#)
-import GHC.Prim (Word#)
-extendWord16# :: Word# -> Word#
-extendWord16# w = w
-{-# INLINE extendWord16# #-}
+import GHC.Word (Word16(..))
+
+#if !MIN_VERSION_base(4,16,0)
+-- harmless to import, except for warnings that it is unused.
+import Data.Text.Internal.PrimCompat ( word16ToWord# )
 #endif
 
 chr2 :: Word16 -> Word16 -> Char
 chr2 (W16# a#) (W16# b#) = C# (chr# (upper# +# lower# +# 0x10000#))
     where
-      !x# = word2Int# (extendWord16# a#)
-      !y# = word2Int# (extendWord16# b#)
+      !x# = word2Int# (word16ToWord# a#)
+      !y# = word2Int# (word16ToWord# b#)
       !upper# = uncheckedIShiftL# (x# -# 0xD800#) 10#
       !lower# = y# -# 0xDC00#
 {-# INLINE chr2 #-}

Data/Text/Internal/Encoding/Utf8.hs

@@ -43,15 +43,12 @@ import Control.Exception (assert)
 import Data.Bits ((.&.))
 import Data.Text.Internal.Unsafe.Char (ord)
 import Data.Text.Internal.Unsafe.Shift (shiftR)
+import GHC.Exts
 import GHC.Word (Word8(..))
 
-#if MIN_VERSION_base(4,16,0)
-import GHC.Exts
-#else
-import GHC.Exts hiding ( extendWord8# )
-extendWord8# :: Word# -> Word#
-extendWord8#  w = w
-{-# INLINE extendWord8# #-}
+#if !MIN_VERSION_base(4,16,0)
+-- harmless to import, except for warnings that it is unused.
+import Data.Text.Internal.PrimCompat (word8ToWord#)
 #endif
 
 default(Int)
@@ -102,18 +99,18 @@ ord4 c =
 chr2 :: Word8 -> Word8 -> Char
 chr2 (W8# x1#) (W8# x2#) = C# (chr# (z1# +# z2#))
     where
-      !y1# = word2Int# (extendWord8# x1#)
-      !y2# = word2Int# (extendWord8# x2#)
+      !y1# = word2Int# (word8ToWord# x1#)
+      !y2# = word2Int# (word8ToWord# x2#)
       !z1# = uncheckedIShiftL# (y1# -# 0xC0#) 6#
       !z2# = y2# -# 0x80#
 {-# INLINE chr2 #-}
 
 chr3 :: Word8 -> Word8 -> Word8 -> Char
 chr3 (W8# x1#) (W8# x2#) (W8# x3#) = C# (chr# (z1# +# z2# +# z3#))
     where
-      !y1# = word2Int# (extendWord8# x1#)
-      !y2# = word2Int# (extendWord8# x2#)
-      !y3# = word2Int# (extendWord8# x3#)
+      !y1# = word2Int# (word8ToWord# x1#)
+      !y2# = word2Int# (word8ToWord# x2#)
+      !y3# = word2Int# (word8ToWord# x3#)
       !z1# = uncheckedIShiftL# (y1# -# 0xE0#) 12#
       !z2# = uncheckedIShiftL# (y2# -# 0x80#) 6#
       !z3# = y3# -# 0x80#
@@ -123,10 +120,10 @@ chr4             :: Word8 -> Word8 -> Word8 -> Word8 -> Char
 chr4 (W8# x1#) (W8# x2#) (W8# x3#) (W8# x4#) =
     C# (chr# (z1# +# z2# +# z3# +# z4#))
     where
-      !y1# = word2Int# (extendWord8# x1#)
-      !y2# = word2Int# (extendWord8# x2#)
-      !y3# = word2Int# (extendWord8# x3#)
-      !y4# = word2Int# (extendWord8# x4#)
+      !y1# = word2Int# (word8ToWord# x1#)
+      !y2# = word2Int# (word8ToWord# x2#)
+      !y3# = word2Int# (word8ToWord# x3#)
+      !y4# = word2Int# (word8ToWord# x4#)
       !z1# = uncheckedIShiftL# (y1# -# 0xF0#) 18#
       !z2# = uncheckedIShiftL# (y2# -# 0x80#) 12#
       !z3# = uncheckedIShiftL# (y3# -# 0x80#) 6#

Data/Text/Internal/PrimCompat.hs

@@ -0,0 +1,37 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
+
+module Data.Text.Internal.PrimCompat
+  ( word8ToWord#
+  , wordToWord8#
+
+  , word16ToWord#
+  , wordToWord16#
+
+  , wordToWord32#
+  , word32ToWord#
+  ) where
+
+#if MIN_VERSION_base(4,16,0)
+
+import GHC.Base
+
+#else
+
+import GHC.Prim (Word#)
+
+wordToWord8#,  word8ToWord#  :: Word# -> Word#
+wordToWord16#, word16ToWord# :: Word# -> Word#
+wordToWord32#, word32ToWord# :: Word# -> Word#
+word8ToWord#  w = w
+word16ToWord# w = w
+word32ToWord# w = w
+wordToWord8#  w = w
+wordToWord16# w = w
+wordToWord32# w = w
+{-# INLINE wordToWord16# #-}
+{-# INLINE word16ToWord# #-}
+{-# INLINE wordToWord32# #-}
+{-# INLINE word32ToWord# #-}
+
+#endif

Data/Text/Internal/Unsafe/Char.hs

@@ -35,34 +35,22 @@ import Data.Text.Internal.Unsafe.Shift (shiftR)
 import GHC.Exts (Char(..), Int(..), chr#, ord#, word2Int#)
 import GHC.Word (Word8(..), Word16(..), Word32(..))
 import qualified Data.Text.Array as A
-
-#if MIN_VERSION_base(4,16,0)
-import GHC.Exts ( extendWord8#, extendWord16#, extendWord32# )
-#else
-import GHC.Prim (Word#)
-extendWord8#, extendWord16#, extendWord32# :: Word# -> Word#
-extendWord8#  w = w
-extendWord16# w = w
-extendWord32# w = w
-{-# INLINE extendWord8# #-}
-{-# INLINE extendWord16# #-}
-{-# INLINE extendWord32# #-}
-#endif
+import Data.Text.Internal.PrimCompat ( word8ToWord#, word16ToWord#, word32ToWord# )
 
 ord :: Char -> Int
 ord (C# c#) = I# (ord# c#)
 {-# INLINE ord #-}
 
 unsafeChr :: Word16 -> Char
-unsafeChr (W16# w#) = C# (chr# (word2Int# (extendWord16# w#)))
+unsafeChr (W16# w#) = C# (chr# (word2Int# (word16ToWord# w#)))
 {-# INLINE unsafeChr #-}
 
 unsafeChr8 :: Word8 -> Char
-unsafeChr8 (W8# w#) = C# (chr# (word2Int# (extendWord8# w#)))
+unsafeChr8 (W8# w#) = C# (chr# (word2Int# (word8ToWord# w#)))
 {-# INLINE unsafeChr8 #-}
 
 unsafeChr32 :: Word32 -> Char
-unsafeChr32 (W32# w#) = C# (chr# (word2Int# (extendWord32# w#)))
+unsafeChr32 (W32# w#) = C# (chr# (word2Int# (word32ToWord# w#)))
 {-# INLINE unsafeChr32 #-}
 
 -- | Write a character into the array at the given offset.  Returns

Data/Text/Internal/Unsafe/Shift.hs

@@ -1,4 +1,5 @@
-{-# LANGUAGE MagicHash, CPP #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
 
 -- |
 -- Module      : Data.Text.Internal.Unsafe.Shift
@@ -21,23 +22,11 @@ module Data.Text.Internal.Unsafe.Shift
     ) where
 
 -- import qualified Data.Bits as Bits
-import GHC.Word
-
-#if MIN_VERSION_base(4,16,0)
 import GHC.Base
-#else
-import GHC.Base hiding (extendWord16#, narrowWord16#)
-import GHC.Prim (Word#)
-extendWord16#, extendWord32# :: Word# -> Word#
-narrowWord16#, narrowWord32# :: Word# -> Word#
-extendWord16# w = w
-extendWord32# w = w
-narrowWord16# w = w
-narrowWord32# w = w
-{-# INLINE narrowWord16# #-}
-{-# INLINE extendWord16# #-}
-{-# INLINE narrowWord32# #-}
-{-# INLINE extendWord32# #-}
+import GHC.Word
+#if !MIN_VERSION_base(4,16,0)
+-- harmless to import, except for warnings that it is unused.
+import Data.Text.Internal.PrimCompat
 #endif
 
 -- | This is a workaround for poor optimisation in GHC 6.8.2.  It
@@ -52,17 +41,17 @@ class UnsafeShift a where
 
 instance UnsafeShift Word16 where
     {-# INLINE shiftL #-}
-    shiftL (W16# x#) (I# i#) = W16# (narrowWord16# ((extendWord16# x#) `uncheckedShiftL#` i#))
+    shiftL (W16# x#) (I# i#) = W16# (wordToWord16# ((word16ToWord# x#) `uncheckedShiftL#` i#))
 
     {-# INLINE shiftR #-}
-    shiftR (W16# x#) (I# i#) = W16# (narrowWord16# ((extendWord16# x#) `uncheckedShiftRL#` i#))
+    shiftR (W16# x#) (I# i#) = W16# (wordToWord16# ((word16ToWord# x#) `uncheckedShiftRL#` i#))
 
 instance UnsafeShift Word32 where
     {-# INLINE shiftL #-}
-    shiftL (W32# x#) (I# i#) = W32# (narrowWord32# ((extendWord32# x#) `uncheckedShiftL#` i#))
+    shiftL (W32# x#) (I# i#) = W32# (wordToWord32# ((word32ToWord# x#) `uncheckedShiftL#` i#))
 
     {-# INLINE shiftR #-}
-    shiftR (W32# x#) (I# i#) = W32# (narrowWord32# ((extendWord32# x#) `uncheckedShiftRL#` i#))
+    shiftR (W32# x#) (I# i#) = W32# (wordToWord32# ((word32ToWord# x#) `uncheckedShiftRL#` i#))
 
 instance UnsafeShift Word64 where
     {-# INLINE shiftL #-}

text.cabal

@@ -119,6 +119,7 @@ library
     Data.Text.Internal.Builder.Functions
     Data.Text.Internal.Builder.Int.Digits
     Data.Text.Internal.Builder.RealFloat.Functions
+    Data.Text.Internal.PrimCompat
     Data.Text.Internal.Encoding.Fusion
     Data.Text.Internal.Encoding.Fusion.Common
     Data.Text.Internal.Encoding.Utf16