Use readFile/writeFile from Data.Text.IO.Utf8 instead of Data.Text.IO

app/Commands/Compile.hs

@@ -4,7 +4,6 @@ import Commands.Base
 import Commands.Compile.Options
 import Commands.Dev.Core.Compile.Base qualified as Compile
 import Commands.Extra.Compile qualified as Compile
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Core qualified as Core
 import Juvix.Compiler.Core.Pretty qualified as Core
 import Juvix.Compiler.Core.Transformation.DisambiguateNames qualified as Core
@@ -35,4 +34,4 @@ writeCoreFile pa@Compile.PipelineArg {..} = do
   case r of
     Left e -> exitJuvixError e
     Right md ->
-      embed $ TIO.writeFile (toFilePath coreFile) (show $ Core.ppOutDefault (Core.disambiguateNames md ^. Core.moduleInfoTable))
+      embed @IO (writeFile (toFilePath coreFile) (show $ Core.ppOutDefault (Core.disambiguateNames md ^. Core.moduleInfoTable)))

app/Commands/Dev/Asm/Compile.hs

@@ -3,7 +3,6 @@ module Commands.Dev.Asm.Compile where
 import Commands.Base
 import Commands.Dev.Asm.Compile.Options
 import Commands.Extra.Compile qualified as Compile
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Asm.Translation.FromSource qualified as Asm
 import Juvix.Compiler.Backend qualified as Backend
 import Juvix.Compiler.Backend.C qualified as C
@@ -29,7 +28,7 @@ runCommand opts = do
           buildDir <- askBuildDir
           ensureDir buildDir
           cFile <- inputCFile file
-          embed $ TIO.writeFile (toFilePath cFile) _resultCCode
+          embed @IO (writeFile (toFilePath cFile) _resultCCode)
           outfile <- Compile.outputFile opts file
           Compile.runCommand
             opts

app/Commands/Dev/Core/Compile/Base.hs

@@ -3,7 +3,6 @@ module Commands.Dev.Core.Compile.Base where
 import Commands.Base
 import Commands.Dev.Core.Compile.Options
 import Commands.Extra.Compile qualified as Compile
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Asm.Pretty qualified as Asm
 import Juvix.Compiler.Backend qualified as Backend
 import Juvix.Compiler.Backend.C qualified as C
@@ -53,7 +52,7 @@ runCPipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   C.MiniCResult {..} <- getRight (run (runReader entryPoint (runError (coreToMiniC _pipelineArgModule :: Sem '[Error JuvixError, Reader EntryPoint] C.MiniCResult))))
   cFile <- inputCFile _pipelineArgFile
-  embed $ TIO.writeFile (toFilePath cFile) _resultCCode
+  embed @IO (writeFile (toFilePath cFile) _resultCCode)
   outfile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile
   Compile.runCommand
     _pipelineArgOptions
@@ -85,7 +84,7 @@ runGebPipeline pa@PipelineArg {..} = do
                       _lispPackageEntry = "*entry*"
                     }
   Geb.Result {..} <- getRight (run (runReader entryPoint (runError (coreToGeb spec _pipelineArgModule :: Sem '[Error JuvixError, Reader EntryPoint] Geb.Result))))
-  embed $ TIO.writeFile (toFilePath gebFile) _resultCode
+  embed @IO (writeFile (toFilePath gebFile) _resultCode)
 
 runVampIRPipeline ::
   forall r.
@@ -96,7 +95,7 @@ runVampIRPipeline pa@PipelineArg {..} = do
   entryPoint <- getEntry pa
   vampirFile <- Compile.outputFile _pipelineArgOptions _pipelineArgFile
   VampIR.Result {..} <- getRight (run (runReader entryPoint (runError (coreToVampIR _pipelineArgModule :: Sem '[Error JuvixError, Reader EntryPoint] VampIR.Result))))
-  embed $ TIO.writeFile (toFilePath vampirFile) _resultCode
+  embed @IO (writeFile (toFilePath vampirFile) _resultCode)
 
 runAsmPipeline :: (Members '[Embed IO, App, TaggedLock] r) => PipelineArg -> Sem r ()
 runAsmPipeline pa@PipelineArg {..} = do
@@ -105,4 +104,4 @@ runAsmPipeline pa@PipelineArg {..} = do
   r <- runReader entryPoint $ runError @JuvixError (coreToAsm _pipelineArgModule)
   tab' <- getRight r
   let code = Asm.ppPrint tab' tab'
-  embed $ TIO.writeFile (toFilePath asmFile) code
+  embed @IO (writeFile (toFilePath asmFile) code)

test/Asm/Compile/Base.hs

@@ -1,7 +1,6 @@
 module Asm.Compile.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Asm.Data.InfoTable
 import Juvix.Compiler.Asm.Error
 import Juvix.Compiler.Asm.Options
@@ -22,7 +21,7 @@ asmCompileAssertion' optLevel tab mainFile expectedFile stdinText step = do
       withTempDir'
         ( \dirPath -> do
             let cFile = dirPath <//> replaceExtension' ".c" (filename mainFile)
-            TIO.writeFile (toFilePath cFile) _resultCCode
+            writeFile (toFilePath cFile) _resultCCode
             Runtime.clangAssertion optLevel cFile expectedFile stdinText step
         )
   where

test/Asm/Run/Base.hs

@@ -1,7 +1,6 @@
 module Asm.Run.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Asm.Data.InfoTable
 import Juvix.Compiler.Asm.Error
 import Juvix.Compiler.Asm.Interpreter
@@ -33,9 +32,9 @@ asmRunAssertion' tab expectedFile step = do
                       ValVoid -> return ()
                       _ -> hPutStrLn hout (ppPrint tab value')
                     hClose hout
-                    actualOutput <- TIO.readFile (toFilePath outputFile)
+                    actualOutput <- readFile (toFilePath outputFile)
                     step "Compare expected and actual program output"
-                    expected <- TIO.readFile (toFilePath expectedFile)
+                    expected <- readFile (toFilePath expectedFile)
                     assertEqDiffText ("Check: RUN output = " <> toFilePath expectedFile) actualOutput expected
             )
         Nothing -> assertFailure "no 'main' function"

test/BackendGeb/Eval/Base.hs

@@ -1,7 +1,6 @@
 module BackendGeb.Eval.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Backend.Geb qualified as Geb
 import Juvix.Prelude.Pretty
 
@@ -52,8 +51,8 @@ gebEvalAssertion' _mainFile expectedFile step gebMorphism = do
         Right value -> do
           hPutStrLn hout (Geb.ppPrint value)
           hClose hout
-          actualOutput <- TIO.readFile (toFilePath outputFile)
-          expected <- TIO.readFile (toFilePath expectedFile)
+          actualOutput <- readFile (toFilePath outputFile)
+          expected <- readFile (toFilePath expectedFile)
           step "Compare expected and actual program output"
           assertEqDiffText
             ("Check: EVAL output = " <> toFilePath expectedFile)

test/BackendGeb/FromCore/Base.hs

@@ -1,7 +1,6 @@
 module BackendGeb.FromCore.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import GHC.Base (seq)
 import Juvix.Compiler.Backend (Target (TargetGeb))
 import Juvix.Compiler.Backend.Geb qualified as Geb
@@ -74,7 +73,7 @@ coreToGebTranslationAssertion' coreInfoTable entryPoint expectedFile step = do
                               assertFailure "The evaluation for the Core node and the Geb node are not equal"
                           | otherwise -> do
                               let fpath = toFilePath expectedFile
-                              expectedInput <- TIO.readFile fpath
+                              expectedInput <- readFile fpath
                               step "Compare expected and actual program output"
                               let compareEvalOutput morph =
                                     if

test/Casm/Run/Base.hs

@@ -1,7 +1,6 @@
 module Casm.Run.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Casm.Error
 import Juvix.Compiler.Casm.Interpreter
 import Juvix.Compiler.Casm.Translation.FromSource
@@ -27,9 +26,9 @@ casmRunAssertion' labi instrs expectedFile step =
                 hout <- openFile (toFilePath outputFile) WriteMode
                 hPrint hout value'
                 hClose hout
-                actualOutput <- TIO.readFile (toFilePath outputFile)
+                actualOutput <- readFile (toFilePath outputFile)
                 step "Compare expected and actual program output"
-                expected <- TIO.readFile (toFilePath expectedFile)
+                expected <- readFile (toFilePath expectedFile)
                 assertEqDiffText ("Check: RUN output = " <> toFilePath expectedFile) actualOutput expected
         )
 

test/Core/Asm/Base.hs

@@ -4,7 +4,6 @@ import Asm.Run.Base qualified as Asm
 import Base
 import Core.Eval.Base
 import Core.Eval.Positive qualified as Eval
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Asm.Translation.FromCore qualified as Asm
 import Juvix.Compiler.Core.Data.Module (computeCombinedInfoTable, moduleFromInfoTable)
 import Juvix.Compiler.Core.Options
@@ -47,7 +46,7 @@ coreAsmAssertion mainFile expectedFile step = do
     Left err -> assertFailure (show (pretty err))
     Right (_, Nothing) -> do
       step "Empty program: compare expected and actual program output"
-      expected <- TIO.readFile (toFilePath expectedFile)
+      expected <- readFile (toFilePath expectedFile)
       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) "" expected
     Right (tabIni, Just node) -> do
       step "Translate"

test/Core/Compile/Base.hs

@@ -4,7 +4,6 @@ import Asm.Compile.Base qualified as Asm
 import Base
 import Core.Eval.Base
 import Core.Eval.Positive qualified as Eval
-import Data.Text.IO qualified as TIO
 import GHC.Base (seq)
 import Juvix.Compiler.Asm.Pretty qualified as Asm
 import Juvix.Compiler.Asm.Translation.FromCore qualified as Asm
@@ -72,7 +71,7 @@ coreCompileAssertion mainFile expectedFile stdinText step = do
     Left err -> assertFailure (show (pretty err))
     Right (_, Nothing) -> do
       step "Empty program: compare expected and actual program output"
-      expected <- TIO.readFile (toFilePath expectedFile)
+      expected <- readFile (toFilePath expectedFile)
       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) "" expected
     Right (tabIni, Just node) ->
       coreCompileAssertion' 3 (setupMainFunction defaultModuleId tabIni node) mainFile expectedFile stdinText step

test/Core/Eval/Base.hs

@@ -5,7 +5,6 @@ import Data.Aeson
 import Data.Aeson.BetterErrors
 import Data.ByteString.Lazy qualified as B
 import Data.HashMap.Strict qualified as HashMap
-import Data.Text.IO qualified as TIO
 import Data.Text.Read
 import GHC.Base (seq)
 import Juvix.Compiler.Core.Data.InfoTable
@@ -78,7 +77,7 @@ coreEvalAssertion' mode tab mainFile expectedFile step =
                         (Info.member kNoDisplayInfo (getInfo value))
                         (hPutStrLn hout (ppPrint (toValue tab value)))
                       hClose hout
-                      actualOutput <- TIO.readFile (toFilePath outputFile)
+                      actualOutput <- readFile (toFilePath outputFile)
                       step "Compare expected and actual program output"
                       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) actualOutput _evalDataOutput
               )
@@ -103,7 +102,7 @@ coreEvalAssertion' mode tab mainFile expectedFile step =
     readEvalData :: [Maybe Text] -> IO (Either String EvalData)
     readEvalData argnames = case mode of
       EvalModePlain -> do
-        expected <- TIO.readFile (toFilePath expectedFile)
+        expected <- readFile (toFilePath expectedFile)
         return $
           Right $
             EvalData
@@ -148,7 +147,7 @@ coreEvalAssertion mainFile expectedFile trans testTrans step = do
     Left err -> assertFailure (show (pretty err))
     Right (_, Nothing) -> do
       step "Compare expected and actual program output"
-      expected <- TIO.readFile (toFilePath expectedFile)
+      expected <- readFile (toFilePath expectedFile)
       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) "" expected
     Right (tabIni, Just node) ->
       case run $ runReader defaultCoreOptions $ runError $ applyTransformations trans $ moduleFromInfoTable $ setupMainFunction defaultModuleId tabIni node of

test/Core/Print/Base.hs

@@ -3,7 +3,6 @@ module Core.Print.Base where
 import Base
 import Core.Eval.Base
 import Core.Eval.Positive qualified as Eval
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Core.Data.Module (computeCombinedInfoTable, moduleFromInfoTable)
 import Juvix.Compiler.Core.Pretty
 import Juvix.Compiler.Core.Transformation.DisambiguateNames (disambiguateNames)
@@ -43,7 +42,7 @@ corePrintAssertion mainFile expectedFile step = do
     Left err -> assertFailure (show (pretty err))
     Right (_, Nothing) -> do
       step "Empty program: compare expected and actual program output"
-      expected <- TIO.readFile (toFilePath expectedFile)
+      expected <- readFile (toFilePath expectedFile)
       assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) "" expected
     Right (tabIni, Just node) -> do
       let m = disambiguateNames (moduleFromInfoTable $ setupMainFunction defaultModuleId tabIni node)

test/Internal/Eval/Base.hs

@@ -3,7 +3,6 @@ module Internal.Eval.Base where
 import Base
 import Core.Eval.Base
 import Data.HashMap.Strict qualified as HashMap
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Core.Data.InfoTable
 import Juvix.Compiler.Core.Extra
 import Juvix.Compiler.Core.Info qualified as Info
@@ -36,9 +35,9 @@ internalCoreAssertion root' mainFile expectedFile step = do
                   (Info.member kNoDisplayInfo (getInfo value))
                   (hPutStrLn hout (ppPrint value))
                 hClose hout
-                actualOutput <- TIO.readFile (toFilePath outputFile)
+                actualOutput <- readFile (toFilePath outputFile)
                 step "Compare expected and actual program output"
-                expected <- TIO.readFile (toFilePath expectedFile)
+                expected <- readFile (toFilePath expectedFile)
                 assertEqDiffText ("Check: EVAL output = " <> toFilePath expectedFile) actualOutput expected
         )
     Nothing -> assertFailure ("No main function registered in: " <> toFilePath mainFile)

test/Runtime/Base.hs

@@ -2,7 +2,6 @@ module Runtime.Base where
 
 import Base
 import Data.FileEmbed
-import Data.Text.IO qualified as TIO
 import System.Process qualified as P
 
 clangCompile ::
@@ -59,7 +58,7 @@ clangAssertion optLevel inputFile expectedFile stdinText step = do
   step "Lookup WASI_SYSROOT_PATH"
   sysrootPath :: Path Abs Dir <- getWasiSysrootPath
 
-  expected <- TIO.readFile (toFilePath expectedFile)
+  expected <- readFile (toFilePath expectedFile)
 
   let executeWasm :: Path Abs File -> IO Text
       executeWasm outputFile = readProcess "wasmer" [toFilePath outputFile] stdinText

test/VampIR/Core/Base.hs

@@ -1,7 +1,6 @@
 module VampIR.Core.Base where
 
 import Base
-import Data.Text.IO qualified as TIO
 import Juvix.Compiler.Backend.VampIR.Translation qualified as VampIR
 import Juvix.Compiler.Core
 import Juvix.Prelude.Pretty
@@ -26,7 +25,7 @@ vampirAssertion' backend tab dataFile step = do
         case run (runReader defaultCoreOptions (runError @JuvixError (coreToVampIR' (moduleFromInfoTable tab)))) of
           Left err -> assertFailure (show (pretty (fromJuvixError @GenericError err)))
           Right VampIR.Result {..} -> do
-            TIO.writeFile (toFilePath vampirFile) _resultCode
+            writeFile (toFilePath vampirFile) _resultCode
 
             step "Check vamp-ir on path"
             assertCmdExists $(mkRelFile "vamp-ir")