add System.FilePath to this conversion

It seems to make sense to convert both System.Directory and
System.FilePath uses to OsPath in one go. This will generally look like
replacing RawFilePath with OsPath in type signatures, and will be driven
by the now absolutely massive pile of compile errors.

Got a few modules building in this new regime.

Sponsored-by: Jack Hill

Build/TestConfig.hs

@@ -11,7 +11,6 @@ import Utility.SystemDirectory
 import Utility.OsPath
 
 import System.IO
-import System.FilePath
 
 type ConfigKey = String
 data ConfigValue =
@@ -106,8 +105,11 @@ findCmdPath k command = do
 		)
   where
 	find d =
-		let f = d </> command
+		let f = toOsPath d </> toOsPath command
-		in ifM (doesFileExist (toOsPath f)) ( return (Just f), return Nothing )
+		in ifM (doesFileExist f)
+			( return (Just (fromOsPath f))
+			, return Nothing
+			)
 
 quiet :: String -> String
 quiet s = s ++ " >/dev/null 2>&1"

Common.hs

@@ -10,7 +10,6 @@ import Data.List as X hiding (head, tail, init, last)
 import Data.Monoid as X
 import Data.Default as X
 
-import System.FilePath as X
 import System.IO as X hiding (FilePath)
 import System.Exit as X
 import System.PosixCompat.Files as X (FileStatus)

Git/Construct.hs

@@ -64,11 +64,11 @@ fromPath dir
 	-- When dir == "foo/.git", git looks for "foo/.git/.git",
 	-- and failing that, uses "foo" as the repository.
 	| (P.pathSeparator `B.cons` ".git") `B.isSuffixOf` canondir =
-		ifM (doesDirectoryExist $ fromRawFilePath dir </> ".git")
+		ifM (doesDirectoryExist $ fromOsPath dir </> ".git")
 			( ret dir
 			, ret (P.takeDirectory canondir)
 			)
-	| otherwise = ifM (doesDirectoryExist (fromRawFilePath dir))
+	| otherwise = ifM (doesDirectoryExist (fromOsPath dir))
 		( checkGitDirFile dir >>= maybe (ret dir) (pure . newFrom)
 		-- git falls back to dir.git when dir doesn't
 		-- exist, as long as dir didn't end with a

Utility/OsPath.hs

@@ -13,17 +13,24 @@
 module Utility.OsPath (
 	OsPath,
 	OsString,
+	RawFilePath,
 	literalOsPath,
 	toOsPath,
 	fromOsPath,
+	module X,
+	getSearchPath,
 ) where
 
 import Utility.FileSystemEncoding
 #ifdef WITH_OSPATH
+import System.OsPath as X hiding (OsPath, OsString)
 import System.OsPath
 import "os-string" System.OsString.Internal.Types
 import qualified Data.ByteString.Short as S
+import qualified System.FilePath.ByteString as PB
 #else
+import System.FilePath.ByteString as X hiding (RawFilePath, getSearchPath)
+import System.FilePath.ByteString (getSearchPath)
 import qualified Data.ByteString as S
 #endif
 
@@ -61,6 +68,10 @@ bytesFromOsPath = S.fromShort . getWindowsString . getOsString
 bytesFromOsPath = S.fromShort . getPosixString . getOsString
 #endif
 
+{- For some reason not included in System.OsPath -}
+getSearchPath :: IO [OsPath]
+getSearchPath = map toOsPath <$> PB.getSearchPath
+
 #else
 {- When not building with WITH_OSPATH, use RawFilePath.
  -}

Utility/Path.hs

@@ -27,13 +27,8 @@ module Utility.Path (
 	searchPathContents,
 ) where
 
-import System.FilePath.ByteString
-#ifdef WITH_OSPATH
-import qualified System.OsPath as P
-#else
-import qualified System.FilePath.ByteString as P
-#endif
 import qualified Data.ByteString as B
+import qualified System.FilePath.ByteString as PB
 import Data.List
 import Data.Maybe
 import Control.Monad
@@ -58,15 +53,15 @@ copyright = author JoeyHess (1996+14)
  - and removing the trailing path separator.
  -
  - On Windows, preserves whichever style of path separator might be used in
- - the input RawFilePaths. This is done because some programs in Windows
+ - the input paths. This is done because some programs in Windows
  - demand a particular path separator -- and which one actually varies!
  -
  - This does not guarantee that two paths that refer to the same location,
  - and are both relative to the same location (or both absolute) will
- - yield the same result. Run both through normalise from System.RawFilePath
+ - yield the same result. Run both through normalise from System.OsPath
  - to ensure that.
  -}
-simplifyPath :: RawFilePath -> RawFilePath
+simplifyPath :: OsPath -> OsPath
 simplifyPath path = dropTrailingPathSeparator $ 
 	joinDrive drive $ joinPath $ norm [] $ splitPath path'
   where
@@ -82,27 +77,27 @@ simplifyPath path = dropTrailingPathSeparator $
 		p' = dropTrailingPathSeparator p
 
 {- takeDirectory "foo/bar/" is "foo/bar". This instead yields "foo" -}
-parentDir :: RawFilePath -> RawFilePath
+parentDir :: OsPath -> OsPath
 parentDir = takeDirectory . dropTrailingPathSeparator
 
 {- Just the parent directory of a path, or Nothing if the path has no
 - parent (ie for "/" or "." or "foo") -}
-upFrom :: RawFilePath -> Maybe RawFilePath
+upFrom :: OsPath -> Maybe OsPath
 upFrom dir
 	| length dirs < 2 = Nothing
-	| otherwise = Just $ joinDrive drive $
+	| otherwise = Just $ joinDrive drive $ toOsPath $
 		B.intercalate (B.singleton pathSeparator) $ init dirs
   where
 	-- on Unix, the drive will be "/" when the dir is absolute,
 	-- otherwise ""
 	(drive, path) = splitDrive dir
-	dirs = filter (not . B.null) $ B.splitWith isPathSeparator path
+	dirs = filter (not . B.null) $ B.splitWith PB.isPathSeparator $ fromOsPath path
 
-{- Checks if the first RawFilePath is, or could be said to contain the second.
+{- Checks if the first path is, or could be said to contain the second.
  - For example, "foo/" contains "foo/bar". Also, "foo", "./foo", "foo/" etc
  - are all equivalent.
  -}
-dirContains :: RawFilePath -> RawFilePath -> Bool
+dirContains :: OsPath -> OsPath -> Bool
 dirContains a b = a == b
 	|| a' == b'
 	|| (a'' `B.isPrefixOf` b' && avoiddotdotb)
@@ -124,7 +119,7 @@ dirContains a b = a == b
 	 - a'' is a prefix of b', so all that needs to be done is drop
 	 - that prefix, and check if the next path component is ".."
 	 -}
-	avoiddotdotb = nodotdot $ B.drop (B.length a'') b'
+	avoiddotdotb = nodotdot $ B.drop (B.length a'') $ fromOsPath b'
 
 	nodotdot p = all (not . isdotdot) (splitPath p)
 	
@@ -161,10 +156,10 @@ dirContains a b = a == b
  - we stop preserving ordering at that point. Presumably a user passing
  - that many paths in doesn't care too much about order of the later ones.
  -}
-segmentPaths :: (a -> RawFilePath) -> [RawFilePath] -> [a] -> [[a]]
+segmentPaths :: (a -> OsPath) -> [OsPath] -> [a] -> [[a]]
 segmentPaths = segmentPaths' (\_ r -> r)
 
-segmentPaths' :: (Maybe RawFilePath -> a -> r) -> (a -> RawFilePath) -> [RawFilePath] -> [a] -> [[r]]
+segmentPaths' :: (Maybe OsPath -> a -> r) -> (a -> OsPath) -> [OsPath] -> [a] -> [[r]]
 segmentPaths' f _ [] new = [map (f Nothing) new]
 segmentPaths' f _ [i] new = [map (f (Just i)) new] -- optimisation
 segmentPaths' f c (i:is) new = 
@@ -179,15 +174,15 @@ segmentPaths' f c (i:is) new =
  - than it would be to run the action separately with each path. In
  - the case of git file list commands, that assumption tends to hold.
  -}
-runSegmentPaths :: (a -> RawFilePath) -> ([RawFilePath] -> IO [a]) -> [RawFilePath] -> IO [[a]]
+runSegmentPaths :: (a -> OsPath) -> ([OsPath] -> IO [a]) -> [OsPath] -> IO [[a]]
 runSegmentPaths c a paths = segmentPaths c paths <$> a paths
 
-runSegmentPaths' :: (Maybe RawFilePath -> a -> r) -> (a -> RawFilePath) -> ([RawFilePath] -> IO [a]) -> [RawFilePath] -> IO [[r]]
+runSegmentPaths' :: (Maybe OsPath -> a -> r) -> (a -> OsPath) -> ([OsPath] -> IO [a]) -> [OsPath] -> IO [[r]]
 runSegmentPaths' si c a paths = segmentPaths' si c paths <$> a paths
 
 {- Checks if a filename is a unix dotfile. All files inside dotdirs
  - count as dotfiles. -}
-dotfile :: RawFilePath -> Bool
+dotfile :: OsPath -> Bool
 dotfile file
 	| f == "." = False
 	| f == ".." = False
@@ -196,11 +191,11 @@ dotfile file
   where
 	f = takeFileName file
 
-{- Similar to splitExtensions, but knows that some things in RawFilePaths
+{- Similar to splitExtensions, but knows that some things in paths
  - after a dot are too long to be extensions. -}
-splitShortExtensions :: RawFilePath -> (RawFilePath, [B.ByteString])
+splitShortExtensions :: OsPath -> (OsPath, [B.ByteString])
 splitShortExtensions = splitShortExtensions' 5 -- enough for ".jpeg"
-splitShortExtensions' :: Int -> RawFilePath -> (RawFilePath, [B.ByteString])
+splitShortExtensions' :: Int -> OsPath -> (OsPath, [B.ByteString])
 splitShortExtensions' maxextension = go []
   where
 	go c f
@@ -217,7 +212,7 @@ splitShortExtensions' maxextension = go []
  - a relative path is not possible and the path is simply
  - returned as-is.
  -}
-relPathDirToFileAbs :: RawFilePath -> RawFilePath -> RawFilePath
+relPathDirToFileAbs :: OsPath -> OsPath -> OsPath
 relPathDirToFileAbs from to
 #ifdef mingw32_HOST_OS
 	| normdrive from /= normdrive to = to
@@ -238,7 +233,7 @@ relPathDirToFileAbs from to
 		-- path separator, which takeDrive leaves on the drive
 		-- letter.
 		. dropWhileEnd (isPathSeparator . fromIntegral . ord)
-		. fromRawFilePath 
+		. fromOsPath 
 		. takeDrive
 #endif
 
@@ -258,11 +253,11 @@ inSearchPath command = isJust <$> searchPath command
  -}
 searchPath :: String -> IO (Maybe OsPath)
 searchPath command
-	| P.isAbsolute command' = copyright $ check command'
+	| isAbsolute command' = copyright $ check command'
 	| otherwise = getSearchPath >>= getM indir . map toOsPath
   where
 	command' = toOsPath command
-	indir d = check (d P.</> command')
+	indir d = check (d </> command')
 	check f = firstM doesFileExist
 #ifdef mingw32_HOST_OS
 		[f, f <> ".exe"]
@@ -281,5 +276,5 @@ searchPathContents p =
 	filterM doesFileExist 
 		=<< (concat <$> (getSearchPath >>= mapM (go . toOsPath)))
   where
-	go d = map (d P.</>) . filter p
+	go d = map (d </>) . filter p
 		<$> catchDefaultIO [] (getDirectoryContents d)

Utility/Tmp/Dir.hs

@@ -1,6 +1,6 @@
 {- Temporary directories
  -
- - Copyright 2010-2022 Joey Hess <id@joeyh.name>
+ - Copyright 2010-2025 Joey Hess <id@joeyh.name>
  -
  - License: BSD-2-clause
  -}
@@ -14,8 +14,6 @@ module Utility.Tmp.Dir (
 ) where
 
 import Control.Monad.IfElse
-import System.FilePath
-import System.Directory
 import Control.Monad.IO.Class
 #ifndef mingw32_HOST_OS
 import System.Posix.Temp (mkdtemp)
@@ -24,18 +22,20 @@ import System.Posix.Temp (mkdtemp)
 import Utility.Exception
 import Utility.Tmp (Template)
 import Utility.OsPath
-import Utility.FileSystemEncoding
+import Utility.SystemDirectory
 
 {- Runs an action with a tmp directory located within the system's tmp
  - directory (or within "." if there is none), then removes the tmp
  - directory and all its contents. -}
-withTmpDir :: (MonadMask m, MonadIO m) => Template -> (FilePath -> m a) -> m a
+withTmpDir :: (MonadMask m, MonadIO m) => Template -> (OsPath -> m a) -> m a
 withTmpDir template a = do
-	topleveltmpdir <- liftIO $ catchDefaultIO "." getTemporaryDirectory
+	topleveltmpdir <- liftIO $
+		catchDefaultIO (literalOsPath ".") getTemporaryDirectory
+	let p = fromOsPath $ topleveltmpdir </> template
 #ifndef mingw32_HOST_OS
 	-- Use mkdtemp to create a temp directory securely in /tmp.
 	bracket
-		(liftIO $ mkdtemp $ topleveltmpdir </> fromRawFilePath (fromOsPath template))
+		(liftIO $ toOsPath <$> mkdtemp p)
 		removeTmpDir
 		a
 #else
@@ -44,21 +44,21 @@ withTmpDir template a = do
 
 {- Runs an action with a tmp directory located within a specified directory,
  - then removes the tmp directory and all its contents. -}
-withTmpDirIn :: (MonadMask m, MonadIO m) => FilePath -> Template -> (FilePath -> m a) -> m a
+withTmpDirIn :: (MonadMask m, MonadIO m) => OsPath -> Template -> (OsPath -> m a) -> m a
 withTmpDirIn tmpdir template = bracketIO create removeTmpDir
   where
 	create = do
 		createDirectoryIfMissing True tmpdir
-		makenewdir (tmpdir </> fromRawFilePath (fromOsPath template)) (0 :: Int)
+		makenewdir (tmpdir </> template) (0 :: Int)
 	makenewdir t n = do
-		let dir = t ++ "." ++ show n
+		let dir = t <> toOsPath ("." ++ show n)
 		catchIOErrorType AlreadyExists (const $ makenewdir t $ n + 1) $ do
 			createDirectory dir
 			return dir
 
 {- Deletes the entire contents of the the temporary directory, if it
  - exists. -}
-removeTmpDir :: MonadIO m => FilePath -> m ()
+removeTmpDir :: MonadIO m => OsPath -> m ()
 removeTmpDir tmpdir = liftIO $ whenM (doesDirectoryExist tmpdir) $ do
 #if mingw32_HOST_OS
 	-- Windows will often refuse to delete a file