Change fromChunk signature for Windows

This is to avoid inadvertant errors e.g. in readRaw we were reading it
as a Word8 array on Windows even though we should be reading it as
Word16.

Author: harendra-kumar

core/src/Streamly/Internal/FileSystem/Path/Common.hs

@@ -1185,15 +1185,16 @@ isValidPath' os path =
         Just _ -> True
 
 {-# INLINE unsafeFromChunk #-}
-unsafeFromChunk :: Array Word8 -> Array a
-unsafeFromChunk = Array.unsafeCast
+unsafeFromChunk :: Array a -> Array a
+unsafeFromChunk = id
 
 {-# INLINE fromChunk #-}
 fromChunk :: forall m a. (MonadThrow m, Unbox a, Integral a) =>
-    OS -> Array Word8 -> m (Array a)
-fromChunk Posix arr =
+    OS -> Array a -> m (Array a)
+fromChunk os arr = validatePath os arr >> pure arr
+{-
     let arr1 = Array.unsafeCast arr :: Array a
-     in validatePath Posix arr1 >> pure arr1
+     in validatePath os arr1 >> pure arr1
 fromChunk Windows arr =
     case Array.cast arr of
         Nothing ->
@@ -1202,6 +1203,7 @@ fromChunk Windows arr =
                 $ "Encoded path length " ++ show (Array.byteLength arr)
                     ++ " is not a multiple of 16-bit."
         Just x -> validatePath Windows x >> pure x
+-}
 
 -- | Convert 'Path' to an array of bytes.
 {-# INLINE toChunk #-}

core/src/Streamly/Internal/FileSystem/PosixPath.hs

@@ -276,11 +276,15 @@ isValidPath = Common.isValidPath Common.OS_NAME
 -- been using it consistently in streamly. We use "bytes" for a stream of
 -- bytes.
 
--- | /Unsafe/: The user is responsible to make sure that the failure cases
--- mentioned in 'fromChunk' cannot occur.
+-- | /Unsafe/: The user is responsible to make sure that the path is valid as
+-- per 'isValidPath'.
 --
 {-# INLINE unsafeFromChunk #-}
+#ifndef IS_WINDOWS
 unsafeFromChunk :: IsPath OS_PATH a => Array Word8 -> a
+#else
+unsafeFromChunk :: IsPath OS_PATH a => Array Word16 -> a
+#endif
 unsafeFromChunk =
 #ifndef DEBUG
     unsafeFromPath . OS_PATH . Common.unsafeFromChunk
@@ -290,13 +294,14 @@ unsafeFromChunk =
 
 -- XXX mkPath?
 
--- | Convert a byte array into a Path:
---
--- * Throws 'InvalidPath' if 'isValidPath' fails on the path.
--- * On Windows, throws 'InvalidPath' if the array length is not aligned on two
--- byte boundary.
+-- | Convert a byte array into a Path.
+-- Throws 'InvalidPath' if 'isValidPath' fails on the path.
 --
+#ifndef IS_WINDOWS
 fromChunk :: (MonadThrow m, IsPath OS_PATH a) => Array Word8 -> m a
+#else
+fromChunk :: (MonadThrow m, IsPath OS_PATH a) => Array Word16 -> m a
+#endif
 fromChunk arr = Common.fromChunk Common.OS_NAME arr >>= fromPath . OS_PATH
 
 -- XXX Should be a Fold instead?
@@ -423,27 +428,18 @@ showRaw p =
             toPath p in show arr
 
 #ifndef IS_WINDOWS
--- | Read a raw array as a path type.
+-- | Parse a raw array of bytes as a path type.
 --
 -- >>> readRaw = fromJust . Path.fromChunk . read
 --
--- >>> arr <- Stream.fold Array.create $ Unicode.encodeUtf8 $ Stream.fromList "hello"
+-- >>> arr = rawFromString "hello"
 -- >>> Path.showRaw $ (Path.readRaw $ show arr :: Path.PosixPath)
 -- "fromList [104,101,108,108,111]"
 --
 -- See also: 'showRaw'.
-#else
--- | Read a raw array as a path type.
---
--- >> readRaw = fromJust . Path.fromChunk . read
---
--- >> arr <- Stream.fold Array.create $ Unicode.encodeUtf16LE $ Stream.fromList "hello"
--- >> Path.showRaw $ (Path.readRaw $ show arr :: Path.WindowsPath)
---
--- See also: 'showRaw'.
-#endif
 readRaw :: IsPath OS_PATH a => [Char] -> a
 readRaw = fromJust . fromChunk . read
+#endif
 
 -- We cannot show decoded path in the Show instance as it may not always
 -- succeed and it depends on the encoding which we may not even know. The

core/src/Streamly/Internal/FileSystem/Windows/ReadDir.hsc

@@ -32,7 +32,6 @@ import Data.Char (ord, isSpace)
 import Data.IORef (IORef, newIORef, readIORef, writeIORef)
 import Foreign.C (CInt(..), CWchar(..), Errno(..), errnoToIOError, peekCWString)
 import Numeric (showHex)
-import Streamly.Internal.Data.Array (Array(..))
 import Streamly.Internal.Data.Unfold.Type (Unfold(..))
 import Streamly.Internal.Data.Stream (Step(..))
 import Streamly.Internal.FileSystem.Path (Path)
@@ -207,9 +206,6 @@ readDirStreamEither _ (DirStream (h, ref, fdata)) =
 
     where
 
-    mkPath :: Array Word8 -> WindowsPath
-    mkPath = Path.unsafeFromChunk
-
     processEntry ptr = do
         let dname = #{ptr WIN32_FIND_DATAW, cFileName} ptr
         dattrs :: #{type DWORD} <-
@@ -220,8 +216,8 @@ readDirStreamEither _ (DirStream (h, ref, fdata)) =
             isMeta <- isMetaDir dname
             if isMeta
             then findNext ptr
-            else return (Just (Left (mkPath (Array.unsafeCast name))))
-        else return (Just (Right (mkPath (Array.unsafeCast name))))
+            else return (Just (Left (Path.unsafeFromChunk name)))
+        else return (Just (Right (Path.unsafeFromChunk name)))
 
     findNext ptr = do
         retval <- liftIO $ c_FindNextFileW h ptr

core/src/Streamly/Internal/FileSystem/WindowsPath.hs

@@ -5,19 +5,21 @@
 >>> :m
 >>> :set -XQuasiQuotes
 >>> import Data.Maybe (fromJust)
+>>> import Data.Word (Word16)
 >>> import qualified Streamly.Data.Stream as Stream
 
 For APIs that have not been released yet.
 
 >>> import Streamly.Internal.FileSystem.WindowsPath (WindowsPath, path)
+>>> import Streamly.Internal.Data.Array (Array)
 >>> import qualified Streamly.Internal.Data.Array as Array
 >>> import qualified Streamly.Internal.FileSystem.WindowsPath as Path
 >>> import qualified Streamly.Internal.Unicode.Stream as Unicode
 
 >>> import Data.Either (Either, isLeft)
 >>> import Control.Exception (SomeException, evaluate, try)
 
->>> rawFromString = Array.fromPureStream . Unicode.encodeUtf8' . Stream.fromList
+>>> rawFromString = Array.fromPureStream . Unicode.encodeUtf16le' . Stream.fromList
 >>> pack = fromJust . Path.fromString
 >>> fails action = (try (evaluate action) :: IO (Either SomeException String)) >>= return . isLeft
 -}
@@ -34,7 +36,6 @@ For APIs that have not been released yet.
 -- | Check if the filepath is valid i.e. does the operating system or the file
 -- system allow such a path in listing or creating files?
 --
--- >>> rawFromString = Array.fromPureStream . Unicode.encodeUtf16le' . Stream.fromList
 -- >>> isValid = Path.isValidPath . rawFromString
 --
 -- >>> isValid ""
@@ -158,6 +159,18 @@ validatePath' = Common.validatePath' Common.Windows
 isValidPath' :: Array Word16 -> Bool
 isValidPath' = Common.isValidPath' Common.Windows
 
+-- | Read a raw array of Word16 as a path type.
+--
+-- >>> readRaw = fromJust . Path.fromChunk . read
+--
+-- >>> arr :: Array Word16 = rawFromString "hello"
+-- >>> Path.showRaw $ (Path.readRaw $ show arr :: Path.WindowsPath)
+-- "fromList [104,101,108,108,111]"
+--
+-- See also: 'showRaw'.
+readRaw :: IsPath OS_PATH a => [Char] -> a
+readRaw = fromJust . fromChunk . read
+
 -- | A path that is attached to a root. "C:\\" is considered an absolute root
 -- and "." as a dynamic root. ".." is not considered a root, "..\/x" or "x\/y"
 -- are not rooted paths.