rename to await

Author: soulomoon

ghcide/session-loader/Development/IDE/Session.hs

@@ -105,7 +105,7 @@ import           Data.HashSet                         (HashSet)
 import qualified Data.HashSet                         as Set
 import           Database.SQLite.Simple
 import           Development.IDE.Core.Tracing         (withTrace)
-import           Development.IDE.Core.WorkerThread    (blockRunInThread,
+import           Development.IDE.Core.WorkerThread    (awaitRunInThread,
                                                        withWorkerQueue)
 import           Development.IDE.Session.Diagnostics  (renderCradleError)
 import           Development.IDE.Types.Shake          (WithHieDb,
@@ -737,7 +737,7 @@ loadSessionWithOptions recorder SessionLoadingOptions{..} rootDir que = do
 
     returnWithVersion $ \file -> do
       -- see Note [Serializing runs in separate thread]
-      blockRunInThread que $ getOptions file
+      awaitRunInThread que $ getOptions file
 
 -- | Run the specific cradle on a specific FilePath via hie-bios.
 -- This then builds dependencies or whatever based on the cradle, gets the

ghcide/src/Development/IDE/Core/Shake.hs

@@ -806,7 +806,7 @@ delayedAction a = do
 --   but actions added via 'shakeEnqueue' will be requeued.
 shakeRestart :: Recorder (WithPriority Log) -> IdeState -> VFSModified -> String -> [DelayedAction ()] -> IO [Key] -> IO ()
 shakeRestart recorder IdeState{..} vfs reason acts ioActionBetweenShakeSession =
-    void $ blockRunInThread (restartQueue shakeExtras) $ do
+    void $ awaitRunInThread (restartQueue shakeExtras) $ do
         withMVar'
             shakeSession
             (\runner -> do

ghcide/src/Development/IDE/Core/WorkerThread.hs

@@ -1,5 +1,5 @@
 module Development.IDE.Core.WorkerThread
-    (withWorkerQueue, blockRunInThread)
+    (withWorkerQueue, awaitRunInThread)
  where
 
 import           Control.Concurrent.Async
@@ -20,7 +20,7 @@ import           Control.Monad.Cont        (ContT (ContT))
 --
 -- `Development.IDE.Core.WorkerThread` module provides a simple api to implement this easily.
 -- * `withWorkerQueue`: accepts an action to run in separate thread and returns a `TQueue` to send the actions to run.
--- * `blockRunInThread` : accepts a `TQueue` and an action to run in separate thread and waits for the result.
+-- * `awaitRunInThread` : accepts a `TQueue` and an action to run in separate thread and waits for the result.
 
 
 -- | withWorkerQueue creates a new TQueue and runs the workerAction in a separate thread.
@@ -34,9 +34,9 @@ withWorkerQueue workerAction = ContT $ \mainAction -> do
                 l <- atomically $ readTQueue q
                 workerAction l
 
--- | blockRunInThread run and wait for the result
-blockRunInThread :: TQueue (IO ()) -> IO result -> IO result
-blockRunInThread q act = do
+-- | awaitRunInThread run and wait for the result
+awaitRunInThread :: TQueue (IO ()) -> IO result -> IO result
+awaitRunInThread q act = do
     -- Take an action from TQueue, run it and
     -- use barrier to wait for the result
     barrier <- newBarrier

ghcide/src/Development/IDE/Main.hs

@@ -24,7 +24,6 @@ import           Control.Monad.IO.Class                   (liftIO)
 import qualified Data.Aeson                               as J
 import           Data.Coerce                              (coerce)
 import           Data.Default                             (Default (def))
-import           Data.Foldable                            (traverse_)
 import           Data.Hashable                            (hashed)
 import qualified Data.HashMap.Strict                      as HashMap
 import           Data.List.Extra                          (intercalate,