Avoid needlessly unboxed buffer address and length

GHC optimises them away, and the code is simpler without
needless unboxed pointer and length.

Author: hs-viktor

Data/ByteString/Builder/Internal.hs

@@ -892,44 +892,43 @@ cstringLiteral = \addr -> builder $ \k br -> do
 cstringUtf8Literal :: Addr# -> Builder
 cstringUtf8Literal = \addr0 -> builder $ \k br -> do
 #if __GLASGOW_HASKELL__ >= 811
-    let len = cstringLength# addr0
+    let len = I# (cstringLength# addr0)
 #else
-    (I# len) <- fromIntegral <$> S.c_strlen (Ptr addr0)
+    len <- fromIntegral <$> S.c_strlen (Ptr addr0)
 #endif
     nullAt <- c_strstr (Ptr addr0) (Ptr "\xc0\x80"#)
-    cstringUtf8_step addr0 len nullAt k br
+    cstringUtf8_step (Ptr addr0) len nullAt k br
 
-cstringUtf8_step :: Addr# -> Int# -> Ptr Word8 -> BuildStep r -> BuildStep r
-cstringUtf8_step addr len ((== nullPtr) -> True) k br =
+cstringUtf8_step :: Ptr Word8-> Int -> Ptr Word8 -> BuildStep r -> BuildStep r
+cstringUtf8_step !ip !len ((== nullPtr) -> True) k br =
     -- Contains no encoded nulls, use simple copy codepath
     wrappedBytesCopyStep (BufferRange ip ipe) k br
   where
-    ip  = Ptr addr
-    ipe = Ptr (addr `plusAddr#` len)
-cstringUtf8_step addr len !nullAt k (BufferRange op0 ope)
+    !ipe = ip `plusPtr` len
+cstringUtf8_step !ip !len !nullAt k (BufferRange op0 ope)
     -- Copy as much of the null-free portion of the string as fits into the
     -- available buffer space. If the string is long enough, we may have asked
     -- for less than its full length, filling the buffer with the rest will go
     -- into the next builder step.
     | avail > nullFree = do
-        when (nullFree > 0) (S.memcpy op0 (Ptr addr) nullFree)
+        when (nullFree > 0) (S.memcpy op0 ip nullFree)
         pokeElemOff op0 nullFree 0
         let !op' = op0 `plusPtr` (nullFree + 1)
-            nread# = nullFree# +# 2#
-            addr' = addr `plusAddr#` nread#
-            len' = len -# nread#
-        nullAt' <- c_strstr (Ptr addr') (Ptr "\xc0\x80"#)
-        cstringUtf8_step addr' len' nullAt' k (BufferRange op' ope)
+            nread = nullFree + 2
+            !ip' = ip `plusPtr` nread
+            len' = len - nread
+        nullAt' <- c_strstr ip' (Ptr "\xc0\x80"#)
+        cstringUtf8_step ip' len' nullAt' k (BufferRange op' ope)
     | otherwise = do
-        let !copy@(I# copy#) = min avail nullFree
-        when (copy > 0) (S.memcpy op0 (Ptr addr) copy)
+        let !copy = min avail nullFree
+        when (copy > 0) (S.memcpy op0 ip copy)
         let !op' = op0 `plusPtr` copy
-            addr' = addr `plusAddr#` copy#
-            len' = len -# copy#
-        return $ bufferFull 1 op' (cstringUtf8_step addr' len' nullAt k)
+            !ip' = ip `plusPtr` copy
+            len' = len - copy
+        return $ bufferFull 1 op' (cstringUtf8_step ip' len' nullAt k)
   where
     !avail = ope `minusPtr` op0
-    !nullFree@(I# nullFree#) = nullAt `minusPtr` (Ptr addr)
+    !nullFree = nullAt `minusPtr` ip
 
 foreign import ccall unsafe "string.h strstr" c_strstr
     :: CString -> CString -> IO (Ptr Word8)