diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 984758a310..5aae5cf86b 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -114,7 +114,7 @@ jobs:
       - if: needs.pre_job.outputs.should_skip_ghcide != 'true' && matrix.test
         name: Test ghcide
         # run the tests without parallelism to avoid running out of memory
-        run: cabal test ghcide-tests || cabal test ghcide-tests
+        run: cabal test ghcide-tests
 
       - if: matrix.test
         name: Test hls-plugin-api
@@ -261,6 +261,10 @@ jobs:
         name: Compile the plugin-tutorial
         run: cabal build plugin-tutorial
 
+      - if: matrix.test
+        name: Test hls-signature-help-plugin test suite
+        run: cabal test hls-signature-help-plugin-tests || cabal test hls-signature-help-plugin-tests
+
   test_post_job:
     if: always()
     runs-on: ubuntu-latest
diff --git a/CODEOWNERS b/CODEOWNERS
index 820661ceeb..8d54022dc5 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -37,6 +37,7 @@
 /plugins/hls-rename-plugin
 /plugins/hls-retrie-plugin @wz1000
 /plugins/hls-semantic-tokens-plugin @soulomoon
+/plugins/hls-signature-help-plugin @jian-lin
 /plugins/hls-splice-plugin @konn
 /plugins/hls-stan-plugin @0rphee
 /plugins/hls-stylish-haskell-plugin @michaelpj
diff --git a/cabal.project b/cabal.project
index 8d8bd080af..d83e432492 100644
--- a/cabal.project
+++ b/cabal.project
@@ -56,3 +56,9 @@ if impl(ghc >= 9.11)
   allow-newer:
     cabal-install-parsers:base,
     cabal-install-parsers:time,
+
+source-repository-package
+  type: git
+  location: https://github.com/soulomoon/lsp.git
+  tag: 640c7c755bf16128e3cb19c257688aa3305ff9f5
+  subdir: lsp lsp-types lsp-test
diff --git a/docs/configuration.md b/docs/configuration.md
index 9da816c09e..66422e5677 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -52,7 +52,7 @@ Here is a list of the additional settings currently supported by `haskell-langua
 Plugins have a generic config to control their behaviour. The schema of such config is:
 
 - `haskell.plugin.${pluginName}.globalOn`: usually with default true. Whether the plugin is enabled at runtime or it is not. That is the option you might use if you want to disable completely a plugin.
-  - Actual plugin names are: `ghcide-code-actions-fill-holes`, `ghcide-completions`, `ghcide-hover-and-symbols`, `ghcide-type-lenses`, `ghcide-code-actions-type-signatures`, `ghcide-code-actions-bindings`, `ghcide-code-actions-imports-exports`, `eval`, `moduleName`, `pragmas`, `importLens`, `class`, `hlint`, `retrie`, `rename`, `splice`, `stan`.
+  - Actual plugin names are: `ghcide-code-actions-fill-holes`, `ghcide-completions`, `ghcide-hover-and-symbols`, `ghcide-type-lenses`, `ghcide-code-actions-type-signatures`, `ghcide-code-actions-bindings`, `ghcide-code-actions-imports-exports`, `eval`, `moduleName`, `pragmas`, `importLens`, `class`, `hlint`, `retrie`, `rename`, `splice`, `stan`, `signatureHelp`.
   - So to disable the import lens with an explicit list of module definitions you could set `haskell.plugin.importLens.globalOn: false`
 - `haskell.plugin.${pluginName}.${lspCapability}On`: usually with default true. Whether a concrete plugin capability is enabled.
   - Capabilities are the different ways a lsp server can interact with the editor. The current available capabilities of the server are: `callHierarchy`, `codeActions`, `codeLens`, `diagnostics`, `hover`, `symbols`, `completion`, `rename`.
@@ -443,22 +443,20 @@ This will install `eglot` and enable it by default in `haskell-mode`.
 To configure `haskell-language-server` we use the `eglot-workspace-configuration` variable.
 With `M-x eglot-show-workspace-configuration` you can see the JSON that `eglot` will send to `haskell-language-server`.
 See <https://joaotavora.github.io/eglot/#Customizing-Eglot> for more information.
-As an example, the setting below will disable the `stan` plugin.
+As an example, the setting below will disable the `stan` plugin and use `fourmolu` for formatting:
 
 ```emacs-lisp
 (use-package eglot
   :ensure t
   :config
-  (add-hook 'haskell-mode-hook 'eglot-ensure)
+  (add-hook 'haskell-mode-hook 'eglot-ensure) ; start eglot automatically in haskell projects
   :config
   (setq-default eglot-workspace-configuration
-                '((haskell
-                   (plugin
-                    (stan
-                     (globalOn . :json-false))))))  ;; disable stan
+                '(:haskell (:plugin (:stan (:globalOn :json-false)) ; disable stan
+                            :formattingProvider "fourmolu")))       ; use fourmolu instead of ormolu
   :custom
-  (eglot-autoshutdown t)  ;; shutdown language server after closing last file
-  (eglot-confirm-server-initiated-edits nil)  ;; allow edits without confirmation
+  (eglot-autoshutdown t)  ; shutdown language server after closing last file
+  (eglot-confirm-server-initiated-edits nil)  ; allow edits without confirmation
   )
 ```
 
diff --git a/docs/features.md b/docs/features.md
index 1eab0054b4..2f34f501cc 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -7,6 +7,7 @@ Many of these are standard LSP features, but a lot of special features are provi
 | --------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
 | [Diagnostics](#diagnostics)                         | `textDocument/publishDiagnostics`                                                                 |
 | [Hovers](#hovers)                                   | `textDocument/hover`                                                                              |
+| [Signature help](#signature-help)                   | `textDocument/signatureHelp`                                                                      |
 | [Jump to definition](#jump-to-definition)           | `textDocument/definition`                                                                         |
 | [Jump to type definition](#jump-to-type-definition) | `textDocument/typeDefinition`                                                                     |
 | [Find references](#find-references)                 | `textDocument/references`                                                                         |
@@ -63,6 +64,12 @@ Provided by: `hls-explicit-fixity-plugin`
 
 Provides fixity information.
 
+## Signature help
+
+Provided by: `hls-signature-help-plugin`
+
+Shows and highlights the function signature, the function documentation and the arguments documentation when the cursor is at a function argument.
+
 ## Jump to definition
 
 Provided by: `ghcide`
@@ -445,7 +452,6 @@ Contributions welcome!
 
 | Feature                | Status            | [LSP method](./what-is-hls.md#lsp-terminology) |
 | ---------------------- | ----------------- | ---------------------------------------------- |
-| Signature help         | Unimplemented     | `textDocument/signatureHelp`                   |
 | Jump to declaration    | Unclear if useful | `textDocument/declaration`                     |
 | Jump to implementation | Unclear if useful | `textDocument/implementation`                  |
 | Linked editing         | Unimplemented     | `textDocument/linkedEditingRange`              |
diff --git a/docs/support/plugin-support.md b/docs/support/plugin-support.md
index 4263f0d035..724ca99da0 100644
--- a/docs/support/plugin-support.md
+++ b/docs/support/plugin-support.md
@@ -51,6 +51,7 @@ For example, a plugin to provide a formatter which has itself been abandoned has
 | `hls-class-plugin`                   | 2    |                          |
 | `hls-change-type-signature-plugin`   | 2    |                          |
 | `hls-eval-plugin`                    | 2    |                          |
+| `hls-signature-help-plugin`          | 2    |                          |
 | `hls-explicit-fixity-plugin`         | 2    |                          |
 | `hls-explicit-record-fields-plugin`  | 2    |                          |
 | `hls-fourmolu-plugin`                | 2    |                          |
diff --git a/ghcide-test/exe/CradleTests.hs b/ghcide-test/exe/CradleTests.hs
index d79b90c835..8edb258257 100644
--- a/ghcide-test/exe/CradleTests.hs
+++ b/ghcide-test/exe/CradleTests.hs
@@ -29,6 +29,7 @@ import           Language.LSP.Protocol.Types     hiding
 import           Language.LSP.Test
 import           System.FilePath
 import           System.IO.Extra                 hiding (withTempDir)
+import           Test.Hls.FileSystem
 import           Test.Hls.Util                   (EnvSpec (..), OS (..),
                                                   ignoreInEnv)
 import           Test.Tasty
@@ -53,7 +54,7 @@ loadCradleOnlyonce = testGroup "load cradle only once"
     ]
     where
         direct dir = do
-            liftIO $ writeFileUTF8 (dir </> "hie.yaml")
+            liftIO $ atomicFileWriteStringUTF8 (dir </> "hie.yaml")
                 "cradle: {direct: {arguments: []}}"
             test dir
         implicit dir = test dir
@@ -73,7 +74,7 @@ retryFailedCradle = testWithDummyPluginEmpty' "retry failed" $ \dir -> do
   -- The false cradle always fails
   let hieContents = "cradle: {bios: {shell: \"false\"}}"
       hiePath = dir </> "hie.yaml"
-  liftIO $ writeFile hiePath hieContents
+  liftIO $ atomicFileWriteString hiePath hieContents
   let aPath = dir </> "A.hs"
   doc <- createDoc aPath "haskell" "main = return ()"
   WaitForIdeRuleResult {..} <- waitForAction "TypeCheck" doc
@@ -81,7 +82,7 @@ retryFailedCradle = testWithDummyPluginEmpty' "retry failed" $ \dir -> do
 
   -- Fix the cradle and typecheck again
   let validCradle = "cradle: {bios: {shell: \"echo A.hs\"}}"
-  liftIO $ writeFileUTF8 hiePath $ T.unpack validCradle
+  liftIO $ atomicFileWriteStringUTF8 hiePath $ T.unpack validCradle
   sendNotification SMethod_WorkspaceDidChangeWatchedFiles $ DidChangeWatchedFilesParams
          [FileEvent (filePathToUri $ dir </> "hie.yaml") FileChangeType_Changed ]
 
@@ -214,7 +215,7 @@ sessionDepsArePickedUp = testWithDummyPluginEmpty'
   "session-deps-are-picked-up"
   $ \dir -> do
     liftIO $
-      writeFileUTF8
+      atomicFileWriteStringUTF8
         (dir </> "hie.yaml")
         "cradle: {direct: {arguments: []}}"
     -- Open without OverloadedStrings and expect an error.
@@ -223,7 +224,7 @@ sessionDepsArePickedUp = testWithDummyPluginEmpty'
 
     -- Update hie.yaml to enable OverloadedStrings.
     liftIO $
-      writeFileUTF8
+      atomicFileWriteStringUTF8
         (dir </> "hie.yaml")
         "cradle: {direct: {arguments: [-XOverloadedStrings]}}"
     sendNotification SMethod_WorkspaceDidChangeWatchedFiles $ DidChangeWatchedFilesParams
diff --git a/ghcide-test/exe/DependentFileTest.hs b/ghcide-test/exe/DependentFileTest.hs
index 1f243819e3..dd2cb2a046 100644
--- a/ghcide-test/exe/DependentFileTest.hs
+++ b/ghcide-test/exe/DependentFileTest.hs
@@ -15,6 +15,7 @@ import           Language.LSP.Protocol.Types    hiding
                                                  mkRange)
 import           Language.LSP.Test
 import           Test.Hls
+import           Test.Hls.FileSystem
 
 
 tests :: TestTree
@@ -31,7 +32,7 @@ tests = testGroup "addDependentFile"
         -- If the file contains B then no type error
         -- otherwise type error
         let depFilePath = "dep-file.txt"
-        liftIO $ writeFile depFilePath "A"
+        liftIO $ atomicFileWriteString depFilePath "A"
         let fooContent = T.unlines
               [ "{-# LANGUAGE TemplateHaskell #-}"
               , "module Foo where"
@@ -48,7 +49,7 @@ tests = testGroup "addDependentFile"
         expectDiagnostics
             [("Foo.hs", [(DiagnosticSeverity_Error, (4,11), "Couldn't match type", Just "GHC-83865")])]
         -- Now modify the dependent file
-        liftIO $ writeFile depFilePath "B"
+        liftIO $ atomicFileWriteString depFilePath "B"
         sendNotification SMethod_WorkspaceDidChangeWatchedFiles $ DidChangeWatchedFilesParams
             [FileEvent (filePathToUri depFilePath) FileChangeType_Changed ]
 
diff --git a/ghcide-test/exe/DiagnosticTests.hs b/ghcide-test/exe/DiagnosticTests.hs
index 52aba0b9b7..a0e9ae2768 100644
--- a/ghcide-test/exe/DiagnosticTests.hs
+++ b/ghcide-test/exe/DiagnosticTests.hs
@@ -39,7 +39,7 @@ import           System.Time.Extra
 import           Test.Hls                        (TestConfig (testConfigCaps, testDirLocation, testDisableKick, testPluginDescriptor),
                                                   runSessionWithTestConfig,
                                                   waitForProgressBegin)
-import           Test.Hls.FileSystem             (directCradle, file, text)
+import           Test.Hls.FileSystem
 import           Test.Tasty
 import           Test.Tasty.HUnit
 
@@ -244,9 +244,7 @@ tests = testGroup "diagnostics"
       _ <- createDoc "ModuleB.hs" "haskell" contentB
       _ <- createDoc "ModuleB.hs-boot" "haskell" contentBboot
       expectDiagnostics [("ModuleB.hs", [(DiagnosticSeverity_Warning, (3,0), "Top-level binding", Just "GHC-38417")])]
-  , testWithDummyPlugin "bidirectional module dependency with hs-boot"
-        (mkIdeTestFs [directCradle ["ModuleA", "ModuleB"]])
-        $ do
+  , testWithDummyPluginEmpty "bidirectional module dependency with hs-boot" $ do
       let contentA = T.unlines
             [ "module ModuleA where"
             , "import {-# SOURCE #-} ModuleB"
@@ -383,7 +381,7 @@ tests = testGroup "diagnostics"
               let (drive, suffix) = splitDrive pathB
               in filePathToUri (joinDrive (lower drive) suffix)
           liftIO $ createDirectoryIfMissing True (takeDirectory pathB)
-          liftIO $ writeFileUTF8 pathB $ T.unpack bContent
+          liftIO $ atomicFileWriteStringUTF8 pathB $ T.unpack bContent
           uriA <- getDocUri "A/A.hs"
           Just pathA <- pure $ uriToFilePath uriA
           uriA <- pure $
diff --git a/ghcide-test/exe/GarbageCollectionTests.hs b/ghcide-test/exe/GarbageCollectionTests.hs
index 5cc9935352..1a867ad747 100644
--- a/ghcide-test/exe/GarbageCollectionTests.hs
+++ b/ghcide-test/exe/GarbageCollectionTests.hs
@@ -12,6 +12,7 @@ import           Language.LSP.Protocol.Types hiding (SemanticTokenAbsolute (..),
                                               SemanticTokensEdit (..), mkRange)
 import           Language.LSP.Test
 import           System.FilePath
+import           Test.Hls.FileSystem
 import           Test.Tasty
 import           Test.Tasty.HUnit
 import           Text.Printf                 (printf)
@@ -20,14 +21,14 @@ tests :: TestTree
 tests = testGroup "garbage collection"
   [ testGroup "dirty keys"
         [ testWithDummyPluginEmpty' "are collected" $ \dir -> do
-            liftIO $ writeFile (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
+            liftIO $ atomicFileWriteString (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
             doc <- generateGarbage "A" dir
             closeDoc doc
             garbage <- waitForGC
             liftIO $ assertBool "no garbage was found" $ not $ null garbage
 
         , testWithDummyPluginEmpty' "are deleted from the state" $ \dir -> do
-            liftIO $ writeFile (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
+            liftIO $ atomicFileWriteString (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
             docA <- generateGarbage "A" dir
             keys0 <- getStoredKeys
             closeDoc docA
@@ -37,7 +38,7 @@ tests = testGroup "garbage collection"
             liftIO $ assertBool "keys were not deleted from the state" (length keys1 < length keys0)
 
         , testWithDummyPluginEmpty' "are not regenerated unless needed" $ \dir -> do
-            liftIO $ writeFile (dir </> "hie.yaml") "cradle: {direct: {arguments: [A.hs, B.hs]}}"
+            liftIO $ atomicFileWriteString (dir </> "hie.yaml") "cradle: {direct: {arguments: [A.hs, B.hs]}}"
             docA <- generateGarbage "A" dir
             _docB <- generateGarbage "B" dir
 
@@ -58,7 +59,7 @@ tests = testGroup "garbage collection"
             liftIO $ regeneratedKeys @?= mempty
 
         , testWithDummyPluginEmpty' "regenerate successfully" $ \dir -> do
-            liftIO $ writeFile (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
+            liftIO $ atomicFileWriteString (dir </> "hie.yaml") "cradle: {direct: {arguments: [A]}}"
             docA <- generateGarbage "A" dir
             closeDoc docA
             garbage <- waitForGC
@@ -83,7 +84,7 @@ tests = testGroup "garbage collection"
         let fp = modName <> ".hs"
             body = printf "module %s where" modName
         doc <- createDoc fp "haskell" (T.pack body)
-        liftIO $ writeFile (dir </> fp) body
+        liftIO $ atomicFileWriteString (dir </> fp) body
         builds <- waitForTypecheck doc
         liftIO $ assertBool "something is wrong with this test" builds
         return doc
diff --git a/ghcide-test/exe/IfaceTests.hs b/ghcide-test/exe/IfaceTests.hs
index d7dc533550..e1e94c926d 100644
--- a/ghcide-test/exe/IfaceTests.hs
+++ b/ghcide-test/exe/IfaceTests.hs
@@ -18,6 +18,7 @@ import           Language.LSP.Test
 import           System.Directory
 import           System.FilePath
 import           System.IO.Extra               hiding (withTempDir)
+import           Test.Hls.FileSystem
 import           Test.Tasty
 import           Test.Tasty.HUnit
 
@@ -45,7 +46,7 @@ ifaceTHTest = testWithExtraFiles "iface-th-test" "TH" $ \dir -> do
     cdoc <- createDoc cPath "haskell" cSource
 
     -- Change [TH]a from () to Bool
-    liftIO $ writeFileUTF8 aPath (unlines $ init (lines $ T.unpack aSource) ++ ["th_a = [d| a = False|]"])
+    liftIO $ atomicFileWriteStringUTF8 aPath (unlines $ init (lines $ T.unpack aSource) ++ ["th_a = [d| a = False|]"])
 
     -- Check that the change propagates to C
     changeDoc cdoc [TextDocumentContentChangeEvent . InR $ TextDocumentContentChangeWholeDocument cSource]
diff --git a/ghcide-test/exe/PluginSimpleTests.hs b/ghcide-test/exe/PluginSimpleTests.hs
index c160d2461c..b15e9af749 100644
--- a/ghcide-test/exe/PluginSimpleTests.hs
+++ b/ghcide-test/exe/PluginSimpleTests.hs
@@ -9,6 +9,7 @@ import           Language.LSP.Protocol.Types hiding (SemanticTokenAbsolute (..),
                                               SemanticTokensEdit (..), mkRange)
 import           Language.LSP.Test
 import           System.FilePath
+import           Test.Hls.FileSystem
 import           Test.Tasty
 
 tests :: TestTree
@@ -36,7 +37,7 @@ tests =
   -- required by plugin-1.0.0). See the build log above for details.
   testWithExtraFiles "simple plugin"  "plugin-knownnat" $ \dir -> do
     _ <- openDoc (dir </> "KnownNat.hs") "haskell"
-    liftIO $ writeFile (dir</>"hie.yaml")
+    liftIO $ atomicFileWriteString (dir</>"hie.yaml")
       "cradle: {cabal: [{path: '.', component: 'lib:plugin'}]}"
 
     expectDiagnostics
diff --git a/ghcide-test/exe/UnitTests.hs b/ghcide-test/exe/UnitTests.hs
index b2940ab27f..dcd5c170f4 100644
--- a/ghcide-test/exe/UnitTests.hs
+++ b/ghcide-test/exe/UnitTests.hs
@@ -31,6 +31,7 @@ import           System.Mem                        (performGC)
 import           Test.Hls                          (IdeState, def,
                                                     runSessionWithServerInTmpDir,
                                                     waitForProgressDone)
+import           Test.Hls.FileSystem
 import           Test.Tasty
 import           Test.Tasty.ExpectedFailure
 import           Test.Tasty.HUnit
@@ -104,9 +105,9 @@ findResolution_us :: Int -> IO Int
 findResolution_us delay_us | delay_us >= 1000000 = error "Unable to compute timestamp resolution"
 findResolution_us delay_us = withTempFile $ \f -> withTempFile $ \f' -> do
     performGC
-    writeFile f ""
+    atomicFileWriteString f ""
     threadDelay delay_us
-    writeFile f' ""
+    atomicFileWriteString f' ""
     t <- getModTime f
     t' <- getModTime f'
     if t /= t' then return delay_us else findResolution_us (delay_us * 10)
diff --git a/ghcide-test/exe/WatchedFileTests.hs b/ghcide-test/exe/WatchedFileTests.hs
index 1c2ded9109..f00e4bfffe 100644
--- a/ghcide-test/exe/WatchedFileTests.hs
+++ b/ghcide-test/exe/WatchedFileTests.hs
@@ -29,7 +29,7 @@ tests :: TestTree
 tests = testGroup "watched files"
   [ testGroup "Subscriptions"
     [ testWithDummyPluginEmpty' "workspace files" $ \sessionDir -> do
-        liftIO $ writeFile (sessionDir </> "hie.yaml") "cradle: {direct: {arguments: [\"-isrc\", \"A\", \"WatchedFilesMissingModule\"]}}"
+        liftIO $ atomicFileWriteString (sessionDir </> "hie.yaml") "cradle: {direct: {arguments: [\"-isrc\", \"A\", \"WatchedFilesMissingModule\"]}}"
         _doc <- createDoc "A.hs" "haskell" "{-#LANGUAGE NoImplicitPrelude #-}\nmodule A where\nimport WatchedFilesMissingModule"
         setIgnoringRegistrationRequests False
         watchedFileRegs <- getWatchedFilesSubscriptionsUntil SMethod_TextDocumentPublishDiagnostics
@@ -40,7 +40,7 @@ tests = testGroup "watched files"
     , testWithDummyPluginEmpty' "non workspace file" $ \sessionDir -> do
         tmpDir <- liftIO getTemporaryDirectory
         let yaml = "cradle: {direct: {arguments: [\"-i" <> tail(init(show tmpDir)) <> "\", \"A\", \"WatchedFilesMissingModule\"]}}"
-        liftIO $ writeFile (sessionDir </> "hie.yaml") yaml
+        liftIO $ atomicFileWriteString (sessionDir </> "hie.yaml") yaml
         _doc <- createDoc "A.hs" "haskell" "{-# LANGUAGE NoImplicitPrelude#-}\nmodule A where\nimport WatchedFilesMissingModule"
         setIgnoringRegistrationRequests False
         watchedFileRegs <- getWatchedFilesSubscriptionsUntil SMethod_TextDocumentPublishDiagnostics
@@ -53,8 +53,8 @@ tests = testGroup "watched files"
   , testGroup "Changes"
     [
       testWithDummyPluginEmpty' "workspace files" $ \sessionDir -> do
-        liftIO $ writeFile (sessionDir </> "hie.yaml") "cradle: {direct: {arguments: [\"-isrc\", \"A\", \"B\"]}}"
-        liftIO $ writeFile (sessionDir </> "B.hs") $ unlines
+        liftIO $ atomicFileWriteString (sessionDir </> "hie.yaml") "cradle: {direct: {arguments: [\"-isrc\", \"A\", \"B\"]}}"
+        liftIO $ atomicFileWriteString (sessionDir </> "B.hs") $ unlines
           ["module B where"
           ,"b :: Bool"
           ,"b = False"]
@@ -66,7 +66,7 @@ tests = testGroup "watched files"
           ]
         expectDiagnostics [("A.hs", [(DiagnosticSeverity_Error, (3, 4), "Couldn't match expected type '()' with actual type 'Bool'", Just "GHC-83865")])]
         -- modify B off editor
-        liftIO $ writeFile (sessionDir </> "B.hs") $ unlines
+        liftIO $ atomicFileWriteString (sessionDir </> "B.hs") $ unlines
           ["module B where"
           ,"b :: Int"
           ,"b = 0"]
@@ -80,7 +80,7 @@ tests = testGroup "watched files"
           let cabalFile = "reload.cabal"
           cabalContent <- liftIO $ T.readFile cabalFile
           let fix = T.replace "build-depends:    base" "build-depends:    base, split"
-          liftIO $ T.writeFile cabalFile (fix cabalContent)
+          liftIO $ atomicFileWriteText cabalFile (fix cabalContent)
           sendNotification SMethod_WorkspaceDidChangeWatchedFiles $ DidChangeWatchedFilesParams
             [ FileEvent (filePathToUri $ sessionDir </> cabalFile) FileChangeType_Changed ]
           expectDiagnostics [(hsFile, [])]
diff --git a/ghcide/ghcide.cabal b/ghcide/ghcide.cabal
index 7dd12f9fef..359b742771 100644
--- a/ghcide/ghcide.cabal
+++ b/ghcide/ghcide.cabal
@@ -142,7 +142,6 @@ library
     Development.IDE.Core.Shake
     Development.IDE.Core.Tracing
     Development.IDE.Core.UseStale
-    Development.IDE.Core.WorkerThread
     Development.IDE.GHC.Compat
     Development.IDE.GHC.Compat.Core
     Development.IDE.GHC.Compat.CmdLine
@@ -179,7 +178,9 @@ library
     Development.IDE.Plugin.Test
     Development.IDE.Plugin.TypeLenses
     Development.IDE.Session
+    Development.IDE.Session.Dependency
     Development.IDE.Session.Diagnostics
+    Development.IDE.Session.Ghc
     Development.IDE.Session.Implicit
     Development.IDE.Spans.AtPoint
     Development.IDE.Spans.Common
@@ -202,6 +203,7 @@ library
     Development.IDE.GHC.CPP
     Development.IDE.GHC.Warnings
     Development.IDE.Types.Action
+    Development.IDE.Session.OrderedSet
 
   if flag(pedantic)
     ghc-options:
diff --git a/ghcide/session-loader/Development/IDE/Session.hs b/ghcide/session-loader/Development/IDE/Session.hs
index dde1cfdea5..2d43724f3f 100644
--- a/ghcide/session-loader/Development/IDE/Session.hs
+++ b/ghcide/session-loader/Development/IDE/Session.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP          #-}
 {-# LANGUAGE TypeFamilies #-}
 
 {-|
@@ -25,49 +24,38 @@ import           Control.Exception.Safe              as Safe
 import           Control.Monad
 import           Control.Monad.Extra                 as Extra
 import           Control.Monad.IO.Class
+import           Control.Monad.Trans.Maybe           (MaybeT (MaybeT, runMaybeT))
 import qualified Crypto.Hash.SHA1                    as H
-import           Data.Aeson                          hiding (Error)
-import           Data.Bifunctor
+import           Data.Aeson                          hiding (Error, Key)
 import qualified Data.ByteString.Base16              as B16
 import qualified Data.ByteString.Char8               as B
 import           Data.Default
-import           Data.Either.Extra
-import           Data.Function
 import           Data.Hashable                       hiding (hash)
 import qualified Data.HashMap.Strict                 as HM
-import           Data.IORef
 import           Data.List
 import           Data.List.Extra                     as L
-import           Data.List.NonEmpty                  (NonEmpty (..))
-import qualified Data.List.NonEmpty                  as NE
 import qualified Data.Map.Strict                     as Map
 import           Data.Maybe
 import           Data.Proxy
 import qualified Data.Text                           as T
-import           Data.Time.Clock
 import           Data.Version
 import           Development.IDE.Core.RuleTypes
 import           Development.IDE.Core.Shake          hiding (Log, knownTargets,
                                                       withHieDb)
 import qualified Development.IDE.GHC.Compat          as Compat
-import           Development.IDE.GHC.Compat.CmdLine
 import           Development.IDE.GHC.Compat.Core     hiding (Target, TargetFile,
                                                       TargetModule, Var,
                                                       Warning, getOptions)
-import qualified Development.IDE.GHC.Compat.Core     as GHC
 import           Development.IDE.GHC.Compat.Env      hiding (Logger)
-import           Development.IDE.GHC.Compat.Units    (UnitId)
 import           Development.IDE.GHC.Util
-import           Development.IDE.Graph               (Action)
+import           Development.IDE.Graph               (Action, Key)
 import qualified Development.IDE.Session.Implicit    as GhcIde
 import           Development.IDE.Types.Diagnostics
 import           Development.IDE.Types.Exports
-import           Development.IDE.Types.HscEnvEq      (HscEnvEq, newHscEnvEq)
+import           Development.IDE.Types.HscEnvEq      (HscEnvEq)
 import           Development.IDE.Types.Location
 import           Development.IDE.Types.Options
-import           GHC.ResponseFile
 import qualified HIE.Bios                            as HieBios
-import qualified HIE.Bios.Cradle.Utils               as HieBios
 import           HIE.Bios.Environment                hiding (getCacheDir)
 import           HIE.Bios.Types                      hiding (Log)
 import qualified HIE.Bios.Types                      as HieBios
@@ -78,7 +66,8 @@ import           Ide.Logger                          (Pretty (pretty),
                                                       nest,
                                                       toCologActionWithPrio,
                                                       vcat, viaShow, (<+>))
-import           Ide.Types                           (SessionLoadingPreferenceConfig (..),
+import           Ide.Types                           (Config,
+                                                      SessionLoadingPreferenceConfig (..),
                                                       sessionLoading)
 import           Language.LSP.Protocol.Message
 import           Language.LSP.Server
@@ -92,26 +81,19 @@ import           Data.Void
 
 import           Control.Concurrent.STM.Stats        (atomically, modifyTVar',
                                                       readTVar, writeTVar)
-import           Control.Concurrent.STM.TQueue
-import           Control.DeepSeq
-import           Control.Exception                   (evaluate)
-import           Control.Monad.IO.Unlift             (MonadUnliftIO)
 import           Control.Monad.Trans.Cont            (ContT (ContT, runContT))
 import           Data.Foldable                       (for_)
 import           Data.HashMap.Strict                 (HashMap)
 import           Data.HashSet                        (HashSet)
 import qualified Data.HashSet                        as Set
-import qualified Data.Set                            as OS
 import           Database.SQLite.Simple
 import           Development.IDE.Core.Tracing        (withTrace)
-import           Development.IDE.Core.WorkerThread   (awaitRunInThread,
-                                                      withWorkerQueue)
-import qualified Development.IDE.GHC.Compat.Util     as Compat
+import           Development.IDE.Session.Dependency
 import           Development.IDE.Session.Diagnostics (renderCradleError)
+import           Development.IDE.Session.Ghc         hiding (Log)
 import           Development.IDE.Types.Shake         (WithHieDb,
                                                       WithHieDbShield (..),
                                                       toNoFileKey)
-import           GHC.Data.Graph.Directed
 import           HieDb.Create
 import           HieDb.Types
 import           Ide.PluginUtils                     (toAbsolute)
@@ -119,15 +101,14 @@ import qualified System.Random                       as Random
 import           System.Random                       (RandomGen)
 import           Text.ParserCombinators.ReadP        (readP_to_S)
 
-import           GHC.Driver.Env                      (hsc_all_home_unit_ids)
-import           GHC.Driver.Errors.Types
-import           GHC.Types.Error                     (errMsgDiagnostic,
-                                                      singleMessage)
-import           GHC.Unit.State
-
-#if MIN_VERSION_ghc(9,13,0)
-import           GHC.Driver.Make                     (checkHomeUnitsClosed)
-#endif
+import           Control.Concurrent.STM              (STM, TVar)
+import qualified Control.Monad.STM                   as STM
+import           Control.Monad.Trans.Reader
+import qualified Development.IDE.Session.Ghc         as Ghc
+import qualified Development.IDE.Session.OrderedSet  as S
+import           Development.IDE.WorkerThread
+import qualified Focus
+import qualified StmContainers.Map                   as STM
 
 data Log
   = LogSettingInitialDynFlags
@@ -137,22 +118,34 @@ data Log
   | LogHieDbRetriesExhausted !Int !Int !Int !SomeException
   | LogHieDbWriterThreadSQLiteError !SQLError
   | LogHieDbWriterThreadException !SomeException
-  | LogInterfaceFilesCacheDir !FilePath
   | LogKnownFilesUpdated !(HashMap Target (HashSet NormalizedFilePath))
-  | LogMakingNewHscEnv ![UnitId]
-  | LogDLLLoadError !String
   | LogCradlePath !FilePath
   | LogCradleNotFound !FilePath
   | LogSessionLoadingResult !(Either [CradleError] (ComponentOptions, FilePath, String))
   | LogCradle !(Cradle Void)
   | LogNoneCradleFound FilePath
-  | LogNewComponentCache !(([FileDiagnostic], Maybe HscEnvEq), DependencyInfo)
   | LogHieBios HieBios.Log
   | LogSessionLoadingChanged
+  | LogSessionNewLoadedFiles ![FilePath]
+  | LogSessionReloadOnError FilePath ![FilePath]
+  | LogGetOptionsLoop !FilePath
+  | LogLookupSessionCache !FilePath
+  | LogTime !String
+  | LogSessionGhc Ghc.Log
+  | LogSessionWorkerThread LogWorkerThread
 deriving instance Show Log
 
+
 instance Pretty Log where
   pretty = \case
+    LogSessionWorkerThread lt -> pretty lt
+    LogTime s -> "Time:" <+> pretty s
+    LogLookupSessionCache path -> "Looking up session cache for" <+> pretty path
+    LogGetOptionsLoop fp -> "Loop: getOptions for" <+> pretty fp
+    LogSessionReloadOnError path files ->
+      "Reloading file due to error in" <+> pretty path <+> "with files:" <+> pretty files
+    LogSessionNewLoadedFiles files ->
+      "New loaded files:" <+> pretty files
     LogNoneCradleFound path ->
       "None cradle found for" <+> pretty path <+> ", ignoring the file"
     LogSettingInitialDynFlags ->
@@ -193,18 +186,12 @@ instance Pretty Log where
         vcat
           [ "HieDb writer thread exception:"
           , pretty (displayException e) ]
-    LogInterfaceFilesCacheDir path ->
-      "Interface files cache directory:" <+> pretty path
     LogKnownFilesUpdated targetToPathsMap ->
       nest 2 $
         vcat
           [ "Known files updated:"
           , viaShow $ (HM.map . Set.map) fromNormalizedFilePath targetToPathsMap
           ]
-    LogMakingNewHscEnv inPlaceUnitIds ->
-      "Making new HscEnv. In-place unit ids:" <+> pretty (map show inPlaceUnitIds)
-    LogDLLLoadError errorString ->
-      "Error dynamically loading libm.so.6:" <+> pretty errorString
     LogCradlePath path ->
       "Cradle path:" <+> pretty path
     LogCradleNotFound path ->
@@ -216,9 +203,8 @@ instance Pretty Log where
       "Session loading result:" <+> viaShow e
     LogCradle cradle ->
       "Cradle:" <+> viaShow cradle
-    LogNewComponentCache componentCache ->
-      "New component cache HscEnvEq:" <+> viaShow componentCache
     LogHieBios msg -> pretty msg
+    LogSessionGhc msg -> pretty msg
     LogSessionLoadingChanged ->
       "Session Loading config changed, reloading the full session."
 
@@ -226,9 +212,6 @@ instance Pretty Log where
 hiedbDataVersion :: String
 hiedbDataVersion = "2"
 
-data CacheDirs = CacheDirs
-  { hiCacheDir, hieCacheDir, oCacheDir :: Maybe FilePath}
-
 data SessionLoadingOptions = SessionLoadingOptions
   { findCradle             :: FilePath -> IO (Maybe FilePath)
   -- | Load the cradle with an optional 'hie.yaml' location.
@@ -381,7 +364,7 @@ runWithDb recorder fp = ContT $ \k -> do
     _ <- withWriteDbRetryable deleteMissingRealFiles
     _ <- withWriteDbRetryable garbageCollectTypeNames
 
-    runContT (withWorkerQueue (writer withWriteDbRetryable)) $ \chan ->
+    runContT (withWorkerQueue (logWith (cmapWithPrio LogSessionWorkerThread recorder) Debug) "hiedb thread"  (writer withWriteDbRetryable)) $ \chan ->
         withHieDb fp (\readDb -> k (WithHieDbShield $ makeWithHieDbRetryable recorder rng readDb, chan))
   where
     writer withHieDbRetryable l = do
@@ -401,6 +384,199 @@ getHieDbLoc dir = do
   createDirectoryIfMissing True cDir
   pure (cDir </> db)
 
+{- Note [SessionState and batch load]
+SessionState manages the state for batch loading files in the session loader.
+
+- When a new file needs to be loaded, it is added to the pendingFiles set.
+- The loader processes files from pendingFiles, attempting to load them in batches.
+- (SBL1) If a file is already in failedFiles, it is loaded individually (single-file mode).
+- (SBL2) Otherwise, the loader tries to load as many files as possible together (batch mode).
+
+On success:
+  - (SBL3) All successfully loaded files are removed from pendingFiles and failedFiles,
+    and added to loadedFiles.
+
+On failure:
+  - (SBL4) If loading a single file fails, it is added to failedFiles and removed from loadedFiles and pendingFiles.
+  - (SBL5) If batch loading fails, all files attempted are added to failedFiles.
+
+This approach ensures efficient batch loading while isolating problematic files for individual handling.
+-}
+
+-- SBL3
+handleBatchLoadSuccess :: Foldable t => Recorder (WithPriority Log) -> SessionState -> Maybe FilePath -> HashMap NormalizedFilePath (IdeResult HscEnvEq, DependencyInfo) -> t TargetDetails -> IO ()
+handleBatchLoadSuccess recorder sessionState hieYaml this_flags_map all_targets =  do
+  pendings <- getPendingFiles sessionState
+  -- this_flags_map might contains files not in pendingFiles, take the intersection
+  let newLoaded = pendings `Set.intersection` Set.fromList (fromNormalizedFilePath <$> HM.keys this_flags_map)
+  atomically $ do
+    STM.insert this_flags_map hieYaml (fileToFlags sessionState)
+    insertAllFileMappings sessionState $ map ((hieYaml,) . fst) $ concatMap toFlagsMap all_targets
+  logWith recorder Info $ LogSessionNewLoadedFiles $ Set.toList newLoaded
+  atomically $ forM_ (Set.toList newLoaded) $ flip S.delete (pendingFiles sessionState)
+  mapM_ (removeErrorLoadingFile sessionState) (Set.toList newLoaded)
+  addCradleFiles sessionState newLoaded
+
+-- SBL5
+handleBatchLoadFailure :: SessionState -> [FilePath] -> IO ()
+handleBatchLoadFailure sessionState files = do
+  mapM_ (addErrorLoadingFile sessionState) files
+
+-- SBL4
+handleSingleLoadFailure :: SessionState -> FilePath -> IO ()
+handleSingleLoadFailure sessionState file = do
+  addErrorLoadingFile sessionState file
+  removeErrorLoadingFile sessionState file
+  atomically $ S.delete file (pendingFiles sessionState)
+  removeCradleFile sessionState file
+
+data SessionState = SessionState
+  { loadedFiles  :: !(Var (HashSet FilePath)),
+    failedFiles  :: !(Var (HashSet FilePath)),
+    pendingFiles :: !(S.OrderedSet FilePath),
+    hscEnvs      :: !(Var HieMap),
+    fileToFlags  :: !FlagsMap,
+    filesMap     :: !FilesMap,
+    version      :: !(Var Int),
+    sessionLoadingPreferenceConfig :: !(Var (Maybe SessionLoadingPreferenceConfig))
+  }
+
+-- | Helper functions for SessionState management
+-- These functions encapsulate common operations on the SessionState
+
+-- | Add a file to the set of files with errors during loading
+addErrorLoadingFile :: MonadIO m =>  SessionState -> FilePath -> m ()
+addErrorLoadingFile state file =
+  liftIO $ modifyVar_' (failedFiles state) (\xs -> return $ Set.insert file xs)
+
+-- | Remove a file from the set of files with errors during loading
+removeErrorLoadingFile :: MonadIO m => SessionState -> FilePath -> m ()
+removeErrorLoadingFile state file =
+  liftIO $ modifyVar_' (failedFiles state) (\xs -> return $ Set.delete file xs)
+
+addCradleFiles :: MonadIO m => SessionState -> HashSet FilePath -> m ()
+addCradleFiles state files =
+  liftIO $ modifyVar_' (loadedFiles state) (\xs -> return $ files <> xs)
+
+-- | Remove a file from the cradle files set
+removeCradleFile :: MonadIO m =>  SessionState -> FilePath -> m ()
+removeCradleFile state file =
+  liftIO $ modifyVar_' (loadedFiles state) (\xs -> return $ Set.delete file xs)
+
+-- | Clear error loading files and reset to empty set
+clearErrorLoadingFiles :: MonadIO m => SessionState -> m ()
+clearErrorLoadingFiles state =
+  liftIO $ modifyVar_' (failedFiles state) (const $ return Set.empty)
+
+-- | Clear cradle files and reset to empty set
+clearCradleFiles :: MonadIO m => SessionState -> m ()
+clearCradleFiles state =
+  liftIO $ modifyVar_' (loadedFiles state) (const $ return Set.empty)
+
+-- | Reset the file maps in the session state
+resetFileMaps :: SessionState -> STM ()
+resetFileMaps state = do
+  STM.reset (filesMap state)
+  STM.reset (fileToFlags state)
+
+-- | Insert or update file flags for a specific hieYaml and normalized file path
+insertFileFlags :: SessionState -> Maybe FilePath -> NormalizedFilePath -> (IdeResult HscEnvEq, DependencyInfo) -> STM ()
+insertFileFlags state hieYaml ncfp flags =
+  STM.focus (Focus.insertOrMerge HM.union (HM.singleton ncfp flags)) hieYaml (fileToFlags state)
+
+-- | Insert a file mapping from normalized path to hieYaml location
+insertFileMapping :: SessionState -> Maybe FilePath -> NormalizedFilePath -> STM ()
+insertFileMapping state hieYaml ncfp =
+  STM.insert hieYaml ncfp (filesMap state)
+
+-- | Remove a file from the pending file set
+removeFromPending :: SessionState -> FilePath -> STM ()
+removeFromPending state file =
+  S.delete file (pendingFiles state)
+
+-- | Add a file to the pending file set
+addToPending :: SessionState -> FilePath -> STM ()
+addToPending state file =
+  S.insert file (pendingFiles state)
+
+-- | Insert multiple file mappings at once
+insertAllFileMappings :: SessionState -> [(Maybe FilePath, NormalizedFilePath)] -> STM ()
+insertAllFileMappings state mappings =
+  mapM_ (\(yaml, path) -> insertFileMapping state yaml path) mappings
+
+-- | Increment the version counter
+incrementVersion :: SessionState -> IO Int
+incrementVersion state = modifyVar' (version state) succ
+
+-- | Get files from the pending file set
+getPendingFiles :: SessionState -> IO (HashSet FilePath)
+getPendingFiles state = atomically $ S.toHashSet (pendingFiles state)
+
+-- | Handle errors during session loading by recording file as having error and removing from pending
+handleSingleFileProcessingError' :: SessionState -> Maybe FilePath -> FilePath -> PackageSetupException -> SessionM ()
+handleSingleFileProcessingError' state hieYaml file e = do
+  handleSingleFileProcessingError state hieYaml file [renderPackageSetupException file e] mempty
+
+-- | Common pattern: Insert file flags, insert file mapping, and remove from pending
+handleSingleFileProcessingError :: SessionState -> Maybe FilePath -> FilePath -> [FileDiagnostic] -> [FilePath] -> SessionM ()
+handleSingleFileProcessingError state hieYaml file diags extraDepFiles = liftIO $ do
+  dep <- getDependencyInfo $ maybeToList hieYaml <> extraDepFiles
+  let ncfp = toNormalizedFilePath' file
+  let flags = ((diags, Nothing), dep)
+  handleSingleLoadFailure state file
+  atomically $ do
+    insertFileFlags state hieYaml ncfp flags
+    insertFileMapping state hieYaml ncfp
+
+-- | Get the set of extra files to load based on the current file path
+-- If the current file is in error loading files, we fallback to single loading mode (empty set)
+-- Otherwise, we remove error files from pending files and also exclude the current file
+getExtraFilesToLoad :: SessionState -> FilePath -> IO [FilePath]
+getExtraFilesToLoad state cfp = do
+  pendingFiles <- getPendingFiles state
+  errorFiles <- readVar (failedFiles state)
+  old_files <- readVar (loadedFiles state)
+  -- if the file is in error loading files, we fall back to single loading mode
+  return $
+    Set.toList $
+      if cfp `Set.member` errorFiles
+        then Set.empty
+        -- remove error files from pending files since error loading need to load one by one
+        else (Set.delete cfp $ pendingFiles `Set.difference` errorFiles) <> old_files
+
+-- | We allow users to specify a loading strategy.
+-- Check whether this config was changed since the last time we have loaded
+-- a session.
+--
+-- If the loading configuration changed, we likely should restart the session
+-- in its entirety.
+didSessionLoadingPreferenceConfigChange :: SessionState -> SessionM Bool
+didSessionLoadingPreferenceConfigChange s = do
+    clientConfig <- asks sessionClientConfig
+    let biosSessionLoadingVar = sessionLoadingPreferenceConfig s
+    mLoadingConfig <- liftIO $ readVar biosSessionLoadingVar
+    case mLoadingConfig of
+        Nothing -> do
+            liftIO $ writeVar biosSessionLoadingVar (Just (sessionLoading clientConfig))
+            pure False
+        Just loadingConfig -> do
+            liftIO $ writeVar biosSessionLoadingVar (Just (sessionLoading clientConfig))
+            pure (loadingConfig /= sessionLoading clientConfig)
+
+newSessionState :: IO SessionState
+newSessionState = do
+  -- Initialize SessionState
+  sessionState <- SessionState
+    <$> newVar (Set.fromList [])  -- loadedFiles
+    <*> newVar (Set.fromList [])  -- failedFiles
+    <*> S.newIO                     -- pendingFiles
+    <*> newVar Map.empty            -- hscEnvs
+    <*> STM.newIO                   -- fileToFlags
+    <*> STM.newIO                   -- filesMap
+    <*> newVar 0                    -- version
+    <*> newVar Nothing              -- sessionLoadingPreferenceConfig
+  return sessionState
+
 -- | Given a root directory, return a Shake 'Action' which setups an
 -- 'IdeGhcSession' given a file.
 -- Some of the many things this does:
@@ -415,23 +591,13 @@ getHieDbLoc dir = do
 -- components mapping to the same hie.yaml file are mapped to the same
 -- HscEnv which is updated as new components are discovered.
 
-loadSessionWithOptions :: Recorder (WithPriority Log) -> SessionLoadingOptions -> FilePath -> TQueue (IO ()) -> IO (Action IdeGhcSession)
+loadSessionWithOptions :: Recorder (WithPriority Log) -> SessionLoadingOptions -> FilePath -> TaskQueue (IO ()) -> IO (Action IdeGhcSession)
 loadSessionWithOptions recorder SessionLoadingOptions{..} rootDir que = do
   let toAbsolutePath = toAbsolute rootDir -- see Note [Root Directory]
-  cradle_files <- newIORef []
-  -- Mapping from hie.yaml file to HscEnv, one per hie.yaml file
-  hscEnvs <- newVar Map.empty :: IO (Var HieMap)
-  -- Mapping from a Filepath to HscEnv
-  fileToFlags <- newVar Map.empty :: IO (Var FlagsMap)
-  -- Mapping from a Filepath to its 'hie.yaml' location.
-  -- Should hold the same Filepaths as 'fileToFlags', otherwise
-  -- they are inconsistent. So, everywhere you modify 'fileToFlags',
-  -- you have to modify 'filesMap' as well.
-  filesMap <- newVar HM.empty :: IO (Var FilesMap)
-  -- Version of the mappings above
-  version <- newVar 0
-  biosSessionLoadingVar <- newVar Nothing :: IO (Var (Maybe SessionLoadingPreferenceConfig))
-  let returnWithVersion fun = IdeGhcSession fun <$> liftIO (readVar version)
+
+  sessionState <- newSessionState
+  let returnWithVersion fun = IdeGhcSession fun <$> liftIO (readVar (version sessionState))
+
   -- This caches the mapping from Mod.hs -> hie.yaml
   cradleLoc <- liftIO $ memoIO $ \v -> do
       res <- findCradle v
@@ -443,277 +609,350 @@ loadSessionWithOptions recorder SessionLoadingOptions{..} rootDir que = do
 
   return $ do
     clientConfig <- getClientConfigAction
-    extras@ShakeExtras{restartShakeSession, ideNc, knownTargetsVar, lspEnv
+    extras@ShakeExtras{ideNc, knownTargetsVar
                       } <- getShakeExtras
     let invalidateShakeCache = do
-            void $ modifyVar' version succ
+            void $ incrementVersion sessionState
             return $ toNoFileKey GhcSessionIO
 
-    IdeOptions{ optTesting = IdeTesting optTesting
-              , optCheckProject = getCheckProject
-              , optExtensions
-              , optHaddockParse
-              } <- getIdeOptions
-
-        -- populate the knownTargetsVar with all the
-        -- files in the project so that `knownFiles` can learn about them and
-        -- we can generate a complete module graph
-    let extendKnownTargets newTargets = do
-          knownTargets <- concatForM  newTargets $ \TargetDetails{..} ->
-            case targetTarget of
-              TargetFile f -> do
-                -- If a target file has multiple possible locations, then we
-                -- assume they are all separate file targets.
-                -- This happens with '.hs-boot' files if they are in the root directory of the project.
-                -- GHC reports options such as '-i. A' as 'TargetFile A.hs' instead of 'TargetModule A'.
-                -- In 'fromTargetId', we dutifully look for '.hs-boot' files and add them to the
-                -- targetLocations of the TargetDetails. Then we add everything to the 'knownTargetsVar'.
-                -- However, when we look for a 'Foo.hs-boot' file in 'FindImports.hs', we look for either
-                --
-                --  * TargetFile Foo.hs-boot
-                --  * TargetModule Foo
-                --
-                -- If we don't generate a TargetFile for each potential location, we will only have
-                -- 'TargetFile Foo.hs' in the 'knownTargetsVar', thus not find 'TargetFile Foo.hs-boot'
-                -- and also not find 'TargetModule Foo'.
-                fs <- filterM (IO.doesFileExist . fromNormalizedFilePath) targetLocations
-                pure $ map (\fp -> (TargetFile fp, Set.singleton fp)) (nubOrd (f:fs))
-              TargetModule _ -> do
-                found <- filterM (IO.doesFileExist . fromNormalizedFilePath) targetLocations
-                return [(targetTarget, Set.fromList found)]
-          hasUpdate <- atomically $ do
-            known <- readTVar knownTargetsVar
-            let known' = flip mapHashed known $ \k -> unionKnownTargets k (mkKnownTargets knownTargets)
-                hasUpdate = if known /= known' then Just (unhashed known') else Nothing
-            writeTVar knownTargetsVar known'
-            pure hasUpdate
-          for_ hasUpdate $ \x ->
-            logWith recorder Debug $ LogKnownFilesUpdated (targetMap x)
-          return $ toNoFileKey GetKnownTargets
-
-    -- Create a new HscEnv from a hieYaml root and a set of options
-    let packageSetup :: (Maybe FilePath, NormalizedFilePath, ComponentOptions, FilePath)
-                     -> IO ([ComponentInfo], [ComponentInfo])
-        packageSetup (hieYaml, cfp, opts, libDir) = do
-          -- Parse DynFlags for the newly discovered component
-          hscEnv <- emptyHscEnv ideNc libDir
-          newTargetDfs <- evalGhcEnv hscEnv $ setOptions optHaddockParse cfp opts (hsc_dflags hscEnv) rootDir
-          let deps = componentDependencies opts ++ maybeToList hieYaml
-          dep_info <- getDependencyInfo (fmap toAbsolutePath deps)
-          -- Now lookup to see whether we are combining with an existing HscEnv
-          -- or making a new one. The lookup returns the HscEnv and a list of
-          -- information about other components loaded into the HscEnv
-          -- (unitId, DynFlag, Targets)
-          modifyVar hscEnvs $ \m -> do
-              -- Just deps if there's already an HscEnv
-              -- Nothing is it's the first time we are making an HscEnv
-              let oldDeps = Map.lookup hieYaml m
-              let -- Add the raw information about this component to the list
-                  -- We will modify the unitId and DynFlags used for
-                  -- compilation but these are the true source of
-                  -- information.
-                  new_deps = fmap (\(df, targets) -> RawComponentInfo (homeUnitId_ df) df targets cfp opts dep_info) newTargetDfs
-                  all_deps = new_deps `NE.appendList` fromMaybe [] oldDeps
-                  -- Get all the unit-ids for things in this component
-                  _inplace = map rawComponentUnitId $ NE.toList all_deps
-
-              all_deps' <- forM all_deps $ \RawComponentInfo{..} -> do
-                  let prefix = show rawComponentUnitId
-                  -- See Note [Avoiding bad interface files]
-                  let cacheDirOpts = componentOptions opts
-                  cacheDirs <- liftIO $ getCacheDirs prefix cacheDirOpts
-                  processed_df <- setCacheDirs recorder cacheDirs rawComponentDynFlags
-                  -- The final component information, mostly the same but the DynFlags don't
-                  -- contain any packages which are also loaded
-                  -- into the same component.
-                  pure $ ComponentInfo
-                           { componentUnitId = rawComponentUnitId
-                           , componentDynFlags = processed_df
-                           , componentTargets = rawComponentTargets
-                           , componentFP = rawComponentFP
-                           , componentCOptions = rawComponentCOptions
-                           , componentDependencyInfo = rawComponentDependencyInfo
-                           }
-              -- Modify the map so the hieYaml now maps to the newly updated
-              -- ComponentInfos
-              -- Returns
-              -- . The information for the new component which caused this cache miss
-              -- . The modified information (without -inplace flags) for
-              --   existing packages
-              let (new,old) = NE.splitAt (NE.length new_deps) all_deps'
-              pure (Map.insert hieYaml (NE.toList all_deps) m, (new,old))
-
-
-    let session :: (Maybe FilePath, NormalizedFilePath, ComponentOptions, FilePath)
-                -> IO (IdeResult HscEnvEq,[FilePath])
-        session args@(hieYaml, _cfp, _opts, _libDir) = do
-          (new_deps, old_deps) <- packageSetup args
-
-          -- For each component, now make a new HscEnvEq which contains the
-          -- HscEnv for the hie.yaml file but the DynFlags for that component
-          -- For GHC's supporting multi component sessions, we create a shared
-          -- HscEnv but set the active component accordingly
-          hscEnv <- emptyHscEnv ideNc _libDir
-          let new_cache = newComponentCache recorder optExtensions _cfp hscEnv
-          all_target_details <- new_cache old_deps new_deps
-
-          this_dep_info <- getDependencyInfo $ maybeToList hieYaml
-          let (all_targets, this_flags_map, this_options)
-                = case HM.lookup _cfp flags_map' of
-                    Just this -> (all_targets', flags_map', this)
-                    Nothing -> (this_target_details : all_targets', HM.insert _cfp this_flags flags_map', this_flags)
-                  where all_targets' = concat all_target_details
-                        flags_map' = HM.fromList (concatMap toFlagsMap all_targets')
-                        this_target_details = TargetDetails (TargetFile _cfp) this_error_env this_dep_info [_cfp]
-                        this_flags = (this_error_env, this_dep_info)
-                        this_error_env = ([this_error], Nothing)
-                        this_error = ideErrorWithSource (Just "cradle") (Just DiagnosticSeverity_Error) _cfp
-                                       (T.unlines
-                                         [ "No cradle target found. Is this file listed in the targets of your cradle?"
-                                         , "If you are using a .cabal file, please ensure that this module is listed in either the exposed-modules or other-modules section"
-                                         ])
-                                       Nothing
-
-          void $ modifyVar' fileToFlags $ Map.insert hieYaml this_flags_map
-          void $ modifyVar' filesMap $ flip HM.union (HM.fromList (map ((,hieYaml) . fst) $ concatMap toFlagsMap all_targets))
-          -- The VFS doesn't change on cradle edits, re-use the old one.
-          -- Invalidate all the existing GhcSession build nodes by restarting the Shake session
-          keys2 <- invalidateShakeCache
-          restartShakeSession VFSUnmodified "new component" [] $ do
-            keys1 <- extendKnownTargets all_targets
-            return [keys1, keys2]
-
-          -- Typecheck all files in the project on startup
-          checkProject <- getCheckProject
-          unless (null new_deps || not checkProject) $ do
-                cfps' <- liftIO $ filterM (IO.doesFileExist . fromNormalizedFilePath) (concatMap targetLocations all_targets)
-                void $ shakeEnqueue extras $ mkDelayedAction "InitialLoad" Debug $ void $ do
-                    mmt <- uses GetModificationTime cfps'
-                    let cs_exist = catMaybes (zipWith (<$) cfps' mmt)
-                    modIfaces <- uses GetModIface cs_exist
-                    -- update exports map
-                    shakeExtras <- getShakeExtras
-                    let !exportsMap' = createExportsMap $ mapMaybe (fmap hirModIface) modIfaces
-                    liftIO $ atomically $ modifyTVar' (exportsMap shakeExtras) (exportsMap' <>)
-
-          return $ second Map.keys this_options
-
-    let consultCradle :: Maybe FilePath -> FilePath -> IO (IdeResult HscEnvEq, [FilePath])
-        consultCradle hieYaml cfp = do
-           let lfpLog = makeRelative rootDir cfp
-           logWith recorder Info $ LogCradlePath lfpLog
-           when (isNothing hieYaml) $
-             logWith recorder Warning $ LogCradleNotFound lfpLog
-           cradle <- loadCradle recorder hieYaml rootDir
-           when optTesting $ mRunLspT lspEnv $
-            sendNotification (SMethod_CustomMethod (Proxy @"ghcide/cradle/loaded")) (toJSON cfp)
-
-           -- Display a user friendly progress message here: They probably don't know what a cradle is
-           let progMsg = "Setting up " <> T.pack (takeBaseName (cradleRootDir cradle))
-                         <> " (for " <> T.pack lfpLog <> ")"
-           eopts <- mRunLspTCallback lspEnv (\act -> withIndefiniteProgress progMsg Nothing NotCancellable (const act)) $
-              withTrace "Load cradle" $ \addTag -> do
-                  addTag "file" lfpLog
-                  old_files <- readIORef cradle_files
-                  res <- cradleToOptsAndLibDir recorder (sessionLoading clientConfig) cradle cfp old_files
-                  addTag "result" (show res)
-                  return res
-
-           logWith recorder Debug $ LogSessionLoadingResult eopts
-           case eopts of
-             -- The cradle gave us some options so get to work turning them
-             -- into and HscEnv.
-             Right (opts, libDir, version) -> do
-               let compileTime = fullCompilerVersion
-               case reverse $ readP_to_S parseVersion version of
-                 [] -> error $ "GHC version could not be parsed: " <> version
-                 ((runTime, _):_)
-                   | compileTime == runTime -> do
-                     atomicModifyIORef' cradle_files (\xs -> (cfp:xs,()))
-                     session (hieYaml, toNormalizedFilePath' cfp, opts, libDir)
-                   | otherwise -> return (([renderPackageSetupException cfp GhcVersionMismatch{..}], Nothing),[])
-             -- Failure case, either a cradle error or the none cradle
-             Left err -> do
-               dep_info <- getDependencyInfo (maybeToList hieYaml)
-               let ncfp = toNormalizedFilePath' cfp
-               let res = (map (\err' -> renderCradleError err' cradle ncfp) err, Nothing)
-               void $ modifyVar' fileToFlags $
-                    Map.insertWith HM.union hieYaml (HM.singleton ncfp (res, dep_info))
-               void $ modifyVar' filesMap $ HM.insert ncfp hieYaml
-               return (res, maybe [] pure hieYaml ++ concatMap cradleErrorDependencies err)
-
-    let
-        -- | We allow users to specify a loading strategy.
-        -- Check whether this config was changed since the last time we have loaded
-        -- a session.
+    ideOptions <- getIdeOptions
+
+    -- see Note [Serializing runs in separate thread]
+    -- Start the getOptionsLoop if the queue is empty
+    liftIO $ atomically $ Extra.whenM (isEmptyTaskQueue que) $ do
+      let newSessionLoadingOptions = SessionLoadingOptions
+            { findCradle = cradleLoc
+            , ..
+            }
+          sessionShake = SessionShake
+            { restartSession = restartShakeSession extras
+            , invalidateCache = invalidateShakeCache
+            , enqueueActions = shakeEnqueue extras
+            }
+          sessionEnv = SessionEnv
+            { sessionLspContext = lspEnv extras
+            , sessionRootDir = rootDir
+            , sessionIdeOptions = ideOptions
+            , sessionClientConfig = clientConfig
+            , sessionSharedNameCache = ideNc
+            , sessionLoadingOptions = newSessionLoadingOptions
+            }
+
+      writeTaskQueue que (runReaderT (getOptionsLoop recorder sessionShake sessionState knownTargetsVar) sessionEnv)
+
+    -- Each one of deps will be registered as a FileSystemWatcher in the GhcSession action
+    -- so that we can get a workspace/didChangeWatchedFiles notification when a dep changes.
+    -- The GlobPattern of a FileSystemWatcher can be absolute or relative.
+    -- We use the absolute one because it is supported by more LSP clients.
+    -- Here we make sure deps are absolute and later we use those absolute deps as GlobPattern.
+    let absolutePathsCradleDeps (eq, deps) = (eq, fmap toAbsolutePath $ Map.keys deps)
+    returnWithVersion $ \file -> do
+      let absFile = toAbsolutePath file
+      absolutePathsCradleDeps <$> lookupOrWaitCache recorder sessionState absFile
+
+-- | Given a file, this function will return the HscEnv and the dependencies
+-- it would look up the cache first, if the cache is not available, it would
+-- submit a request to the getOptionsLoop to get the options for the file
+-- and wait until the options are available
+lookupOrWaitCache :: Recorder (WithPriority Log) -> SessionState -> FilePath -> IO (IdeResult HscEnvEq, DependencyInfo)
+lookupOrWaitCache recorder sessionState absFile = do
+  let ncfp = toNormalizedFilePath' absFile
+  res <- atomically $ do
+      -- wait until target file is not in pendingFiles
+      Extra.whenM (S.lookup absFile (pendingFiles sessionState)) STM.retry
+      -- check if in the cache
+      checkInCache sessionState ncfp
+  logWith recorder Debug $ LogLookupSessionCache absFile
+  updateDateRes <-  case res of
+    Just r -> do
+        depOk <- checkDependencyInfo (snd r)
+        if depOk
+            then return $ Just r
+            else return Nothing
+    _ -> return Nothing
+  case updateDateRes of
+    Just r -> return r
+    Nothing -> do
+      -- if not ok, we need to reload the session
+      atomically $ addToPending sessionState absFile
+      lookupOrWaitCache recorder sessionState absFile
+
+checkInCache :: SessionState -> NormalizedFilePath -> STM (Maybe (IdeResult HscEnvEq, DependencyInfo))
+checkInCache sessionState ncfp = runMaybeT $ do
+  cachedHieYamlLocation <- MaybeT $ STM.lookup ncfp (filesMap sessionState)
+  m <- MaybeT $ STM.lookup cachedHieYamlLocation (fileToFlags sessionState)
+  MaybeT $ pure $ HM.lookup ncfp m
+
+data SessionShake = SessionShake
+  { restartSession :: VFSModified -> String -> [DelayedAction ()] -> IO [Key] -> IO ()
+  , invalidateCache :: IO Key
+  , enqueueActions :: DelayedAction () -> IO (IO ())
+  }
+
+data SessionEnv = SessionEnv
+  { sessionLspContext      :: Maybe (LanguageContextEnv Config)
+  , sessionRootDir         :: FilePath
+  , sessionIdeOptions      :: IdeOptions
+  , sessionClientConfig    :: Config
+  , sessionSharedNameCache :: NameCache
+  , sessionLoadingOptions  :: SessionLoadingOptions
+  }
+
+type SessionM = ReaderT SessionEnv IO
+
+-- | The main function which gets options for a file.
+--
+-- The general approach is as follows:
+-- 1. Find the 'hie.yaml' for the next file target, if there is any.
+-- 2. Check in the cache, whether the given 'hie.yaml' was already loaded before
+-- 3.1. If it wasn't, initialise a new session and continue with step 4.
+-- 3.2. If it is loaded, check whether we need to reload the session, e.g. because the `.cabal` file was modified
+-- 3.2.1. If we need to reload, remove the
+getOptionsLoop :: Recorder (WithPriority Log) -> SessionShake -> SessionState -> TVar (Hashed KnownTargets) -> SessionM ()
+getOptionsLoop recorder sessionShake sessionState knownTargetsVar = forever $ do
+  -- Get the next file to load
+  file <- liftIO $ atomically $ S.readQueue (pendingFiles sessionState)
+  logWith recorder Debug (LogGetOptionsLoop file)
+  let ncfp = toNormalizedFilePath' file
+  cachedHieYamlLocation <- join <$> liftIO (atomically (STM.lookup ncfp (filesMap sessionState)))
+  sessionLoadingOptions <- asks sessionLoadingOptions
+  hieYaml <- liftIO $ findCradle sessionLoadingOptions file
+  let hieLoc = cachedHieYamlLocation <|> hieYaml
+  sessionOpts recorder sessionShake sessionState knownTargetsVar (hieLoc, file)
+    `Safe.catch` handleSingleFileProcessingError' sessionState hieLoc file
+
+-- | This caches the mapping from hie.yaml + Mod.hs -> [String]
+-- Returns the Ghc session and the cradle dependencies
+sessionOpts :: Recorder (WithPriority Log) -> SessionShake -> SessionState -> TVar (Hashed KnownTargets) -> (Maybe FilePath, FilePath) -> SessionM ()
+sessionOpts recorder sessionShake sessionState knownTargetsVar (hieYaml, file) = do
+  Extra.whenM (didSessionLoadingPreferenceConfigChange sessionState) $ do
+    logWith recorder Info LogSessionLoadingChanged
+    liftIO $ atomically $ resetFileMaps sessionState
+    -- Don't even keep the name cache, we start from scratch here!
+    liftIO $ modifyVar_ (hscEnvs sessionState) (const (return Map.empty))
+    -- cleanup error loading files and cradle files
+    clearErrorLoadingFiles sessionState
+    clearCradleFiles sessionState
+    cacheKey <- liftIO $ invalidateCache sessionShake
+    liftIO $ restartSession sessionShake VFSUnmodified "didSessionLoadingPreferenceConfigChange" [] (return [cacheKey])
+
+  v <- liftIO $ atomically $ STM.lookup hieYaml (fileToFlags sessionState)
+  case v >>= HM.lookup (toNormalizedFilePath' file) of
+    Just (_opts, old_di) -> do
+      deps_ok <- liftIO $ checkDependencyInfo old_di
+      if not deps_ok
+        then do
+          -- if deps are old, we can try to load the error files again
+          removeErrorLoadingFile sessionState file
+          removeCradleFile sessionState file
+          -- If the dependencies are out of date then clear both caches and start
+          -- again.
+          liftIO $ atomically $ resetFileMaps sessionState
+          -- Keep the same name cache
+          liftIO $ modifyVar_ (hscEnvs sessionState) (return . Map.adjust (const []) hieYaml)
+          consultCradle recorder sessionShake sessionState knownTargetsVar hieYaml file
+        else do
+          -- if deps are ok, we can just remove the file from pending files
+          liftIO $ atomically $ removeFromPending sessionState file
+    Nothing ->
+        consultCradle recorder sessionShake sessionState knownTargetsVar hieYaml file
+
+consultCradle :: Recorder (WithPriority Log) -> SessionShake -> SessionState -> TVar (Hashed KnownTargets) -> Maybe FilePath -> FilePath -> SessionM ()
+consultCradle recorder sessionShake sessionState knownTargetsVar hieYaml cfp = do
+  loadingOptions <- asks sessionLoadingOptions
+  (cradle, eopts) <- loadCradleWithNotifications recorder
+    sessionState
+    (loadCradle loadingOptions recorder)
+    hieYaml cfp
+  logWith recorder Debug $ LogSessionLoadingResult eopts
+  let ncfp = toNormalizedFilePath' cfp
+  case eopts of
+    -- The cradle gave us some options so get to work turning them
+    -- into and HscEnv.
+    Right (opts, libDir, version) -> do
+      let compileTime = fullCompilerVersion
+      case reverse $ readP_to_S parseVersion version of
+        [] -> error $ "GHC version could not be parsed: " <> version
+        ((runTime, _):_)
+          | compileTime == runTime -> session recorder sessionShake sessionState knownTargetsVar (hieYaml, ncfp, opts, libDir)
+          | otherwise -> handleSingleFileProcessingError' sessionState hieYaml cfp (GhcVersionMismatch{..})
+    -- Failure case, either a cradle error or the none cradle
+    Left err -> do
+        -- what if the error to load file is one of old_files ?
+        let attemptToLoadFiles = Set.delete cfp $ Set.fromList $ concatMap cradleErrorLoadingFiles err
+        old_files <- liftIO $ readVar (loadedFiles sessionState)
+        let errorToLoadNewFiles = cfp : Set.toList (attemptToLoadFiles `Set.difference` old_files)
+        if length errorToLoadNewFiles > 1
+        then do
+            -- we are loading more files and failed, we need to retry
+            -- mark as less loaded files as failedLoadingFiles as possible
+            -- limitation is that when we are loading files, and the dependencies of old_files
+            -- are changed, and old_files are not valid anymore.
+            -- but they will still be in the old_files, and will not move to failedFiles.
+            -- And make other files failed to load in batch mode.
+            liftIO $ handleBatchLoadFailure sessionState errorToLoadNewFiles
+            -- retry without other files
+            logWith recorder Info $ LogSessionReloadOnError cfp (Set.toList attemptToLoadFiles)
+            consultCradle recorder sessionShake sessionState knownTargetsVar hieYaml cfp
+        else do
+            -- we are only loading this file and it failed
+            let res = map (\err' -> renderCradleError err' cradle ncfp) err
+            handleSingleFileProcessingError sessionState hieYaml cfp res $ concatMap cradleErrorDependencies err
+
+session ::
+    Recorder (WithPriority Log) ->
+    SessionShake ->
+    SessionState ->
+    TVar (Hashed KnownTargets) ->
+    (Maybe FilePath, NormalizedFilePath, ComponentOptions, FilePath) ->
+    SessionM ()
+session recorder sessionShake sessionState knownTargetsVar(hieYaml, cfp, opts, libDir) = do
+  let initEmptyHscEnv = emptyHscEnvM libDir
+  (new_deps, old_deps) <- packageSetup recorder sessionState initEmptyHscEnv (hieYaml, cfp, opts)
+
+  -- For each component, now make a new HscEnvEq which contains the
+  -- HscEnv for the hie.yaml file but the DynFlags for that component
+  -- For GHC's supporting multi component sessions, we create a shared
+  -- HscEnv but set the active component accordingly
+  hscEnv <- initEmptyHscEnv
+  ideOptions <- asks sessionIdeOptions
+  let new_cache = newComponentCache (cmapWithPrio LogSessionGhc recorder) (optExtensions ideOptions) cfp hscEnv
+  all_target_details <- liftIO $ new_cache old_deps new_deps
+  (all_targets, this_flags_map) <- liftIO $ addErrorTargetIfUnknown all_target_details hieYaml cfp
+  -- The VFS doesn't change on cradle edits, re-use the old one.
+  -- Invalidate all the existing GhcSession build nodes by restarting the Shake session
+  liftIO $ do
+    checkProject <- optCheckProject ideOptions
+    restartSession sessionShake VFSUnmodified "new component" [] $ do
+        -- It is necessary to call handleBatchLoadSuccess in restartSession
+        -- to ensure the GhcSession rule does not return before a new session is started.
+        -- Otherwise, invalid compilation results may propagate to downstream rules,
+        -- potentially resulting in lost diagnostics and other issues.
+        handleBatchLoadSuccess recorder sessionState hieYaml this_flags_map all_targets
+        keys2 <- invalidateCache sessionShake
+        keys1 <- extendKnownTargets recorder knownTargetsVar all_targets
+        -- Typecheck all files in the project on startup
+        unless (null new_deps || not checkProject) $ do
+            cfps' <- liftIO $ filterM (IO.doesFileExist . fromNormalizedFilePath) (concatMap targetLocations all_targets)
+            void $ enqueueActions sessionShake $ mkDelayedAction "InitialLoad" Debug $ void $ do
+                mmt <- uses GetModificationTime cfps'
+                let cs_exist = catMaybes (zipWith (<$) cfps' mmt)
+                modIfaces <- uses GetModIface cs_exist
+                -- update exports map
+                shakeExtras <- getShakeExtras
+                let !exportsMap' = createExportsMap $ mapMaybe (fmap hirModIface) modIfaces
+                liftIO $ atomically $ modifyTVar' (exportsMap shakeExtras) (exportsMap' <>)
+        return [keys1, keys2]
+
+-- | Create a new HscEnv from a hieYaml root and a set of options
+packageSetup :: Recorder (WithPriority Log) -> SessionState -> SessionM HscEnv -> (Maybe FilePath, NormalizedFilePath, ComponentOptions) -> SessionM ([ComponentInfo], [ComponentInfo])
+packageSetup recorder sessionState newEmptyHscEnv (hieYaml, cfp, opts) = do
+  getCacheDirs <- asks (getCacheDirs . sessionLoadingOptions)
+  haddockparse <- asks (optHaddockParse . sessionIdeOptions)
+  rootDir <- asks sessionRootDir
+  -- Parse DynFlags for the newly discovered component
+  hscEnv <- newEmptyHscEnv
+  newTargetDfs <- liftIO $ evalGhcEnv hscEnv $ setOptions haddockparse cfp opts (hsc_dflags hscEnv) rootDir
+  let deps = componentDependencies opts ++ maybeToList hieYaml
+  dep_info <- liftIO $ getDependencyInfo (fmap (toAbsolute rootDir) deps)
+  -- Now lookup to see whether we are combining with an existing HscEnv
+  -- or making a new one. The lookup returns the HscEnv and a list of
+  -- information about other components loaded into the HscEnv
+  -- (unitId, DynFlag, Targets)
+  liftIO $ modifyVar (hscEnvs sessionState) $
+    addComponentInfo (cmapWithPrio LogSessionGhc recorder) getCacheDirs dep_info newTargetDfs (hieYaml, cfp, opts)
+
+addErrorTargetIfUnknown :: Foldable t => t [TargetDetails] -> Maybe FilePath -> NormalizedFilePath -> IO ([TargetDetails], HashMap NormalizedFilePath (IdeResult HscEnvEq, DependencyInfo))
+addErrorTargetIfUnknown all_target_details hieYaml cfp = do
+  let flags_map' = HM.fromList (concatMap toFlagsMap all_targets')
+      all_targets' = concat all_target_details
+  this_dep_info <- getDependencyInfo $ maybeToList hieYaml
+  let (all_targets, this_flags_map) = case HM.lookup cfp flags_map' of
+        Just _ -> (all_targets', flags_map')
+        Nothing -> (this_target_details : all_targets', HM.insert cfp this_flags flags_map')
+          where
+                this_target_details = TargetDetails (TargetFile cfp) this_error_env this_dep_info [cfp]
+                this_flags = (this_error_env, this_dep_info)
+                this_error_env = ([this_error], Nothing)
+                this_error = ideErrorWithSource (Just "cradle") (Just DiagnosticSeverity_Error) cfp
+                                (T.unlines
+                                  [ "No cradle target found. Is this file listed in the targets of your cradle?"
+                                  , "If you are using a .cabal file, please ensure that this module is listed in either the exposed-modules or other-modules section"
+                                  ])
+                                Nothing
+  pure (all_targets, this_flags_map)
+
+-- | Populate the knownTargetsVar with all the
+-- files in the project so that `knownFiles` can learn about them and
+-- we can generate a complete module graph
+extendKnownTargets :: Recorder (WithPriority Log) -> TVar (Hashed KnownTargets) -> [TargetDetails] -> IO Key
+extendKnownTargets recorder knownTargetsVar newTargets = do
+  knownTargets <- concatForM  newTargets $ \TargetDetails{..} ->
+    case targetTarget of
+      TargetFile f -> do
+        -- If a target file has multiple possible locations, then we
+        -- assume they are all separate file targets.
+        -- This happens with '.hs-boot' files if they are in the root directory of the project.
+        -- GHC reports options such as '-i. A' as 'TargetFile A.hs' instead of 'TargetModule A'.
+        -- In 'fromTargetId', we dutifully look for '.hs-boot' files and add them to the
+        -- targetLocations of the TargetDetails. Then we add everything to the 'knownTargetsVar'.
+        -- However, when we look for a 'Foo.hs-boot' file in 'FindImports.hs', we look for either
         --
-        -- If the loading configuration changed, we likely should restart the session
-        -- in its entirety.
-        didSessionLoadingPreferenceConfigChange :: IO Bool
-        didSessionLoadingPreferenceConfigChange = do
-          mLoadingConfig <- readVar biosSessionLoadingVar
-          case mLoadingConfig of
-            Nothing -> do
-              writeVar biosSessionLoadingVar (Just (sessionLoading clientConfig))
-              pure False
-            Just loadingConfig -> do
-              writeVar biosSessionLoadingVar (Just (sessionLoading clientConfig))
-              pure (loadingConfig /= sessionLoading clientConfig)
-
-    -- This caches the mapping from hie.yaml + Mod.hs -> [String]
-    -- Returns the Ghc session and the cradle dependencies
-    let sessionOpts :: (Maybe FilePath, FilePath)
-                    -> IO (IdeResult HscEnvEq, [FilePath])
-        sessionOpts (hieYaml, file) = do
-          Extra.whenM didSessionLoadingPreferenceConfigChange $ do
-            logWith recorder Info LogSessionLoadingChanged
-            -- If the dependencies are out of date then clear both caches and start
-            -- again.
-            modifyVar_ fileToFlags (const (return Map.empty))
-            modifyVar_ filesMap (const (return HM.empty))
-            -- Don't even keep the name cache, we start from scratch here!
-            modifyVar_ hscEnvs (const (return Map.empty))
-
-          v <- Map.findWithDefault HM.empty hieYaml <$> readVar fileToFlags
-          let cfp = toAbsolutePath file
-          case HM.lookup (toNormalizedFilePath' cfp) v of
-            Just (opts, old_di) -> do
-              deps_ok <- checkDependencyInfo old_di
-              if not deps_ok
-                then do
-                  -- If the dependencies are out of date then clear both caches and start
-                  -- again.
-                  modifyVar_ fileToFlags (const (return Map.empty))
-                  modifyVar_ filesMap (const (return HM.empty))
-                  -- Keep the same name cache
-                  modifyVar_ hscEnvs (return . Map.adjust (const []) hieYaml )
-                  consultCradle hieYaml cfp
-                else return (opts, Map.keys old_di)
-            Nothing -> consultCradle hieYaml cfp
-
-    -- The main function which gets options for a file. We only want one of these running
-    -- at a time. Therefore the IORef contains the currently running cradle, if we try
-    -- to get some more options then we wait for the currently running action to finish
-    -- before attempting to do so.
-    let getOptions :: FilePath -> IO (IdeResult HscEnvEq, [FilePath])
-        getOptions file = do
-            let ncfp = toNormalizedFilePath' (toAbsolutePath file)
-            cachedHieYamlLocation <- HM.lookup ncfp <$> readVar filesMap
-            hieYaml <- cradleLoc file
-            let
-              -- Each one of deps will be registered as a FileSystemWatcher in the GhcSession action
-              -- so that we can get a workspace/didChangeWatchedFiles notification when a dep changes.
-              -- The GlobPattern of a FileSystemWatcher can be absolute or relative.
-              -- We use the absolute one because it is supported by more LSP clients.
-              -- Here we make sure deps are absolute and later we use those absolute deps as GlobPattern.
-              absolutePathsCradleDeps (eq, deps)
-                = (eq, fmap toAbsolutePath deps)
-            (absolutePathsCradleDeps <$> sessionOpts (join cachedHieYamlLocation <|> hieYaml, file))  `Safe.catch` \e ->
-                return (([renderPackageSetupException file e], Nothing), maybe [] pure hieYaml)
+        --  * TargetFile Foo.hs-boot
+        --  * TargetModule Foo
+        --
+        -- If we don't generate a TargetFile for each potential location, we will only have
+        -- 'TargetFile Foo.hs' in the 'knownTargetsVar', thus not find 'TargetFile Foo.hs-boot'
+        -- and also not find 'TargetModule Foo'.
+        fs <- filterM (IO.doesFileExist . fromNormalizedFilePath) targetLocations
+        pure $ map (\fp -> (TargetFile fp, Set.singleton fp)) (nubOrd (f:fs))
+      TargetModule _ -> do
+        found <- filterM (IO.doesFileExist . fromNormalizedFilePath) targetLocations
+        return [(targetTarget, Set.fromList found)]
+  hasUpdate <- atomically $ do
+    known <- readTVar knownTargetsVar
+    let known' = flip mapHashed known $ \k -> unionKnownTargets k (mkKnownTargets knownTargets)
+        hasUpdate = if known /= known' then Just (unhashed known') else Nothing
+    writeTVar knownTargetsVar known'
+    pure hasUpdate
+  for_ hasUpdate $ \x ->
+    logWith recorder Debug $ LogKnownFilesUpdated (targetMap x)
+  return $ toNoFileKey GetKnownTargets
+
+
+loadCradleWithNotifications ::
+  Recorder (WithPriority Log) ->
+  SessionState ->
+  (Maybe FilePath -> FilePath -> IO (Cradle Void)) ->
+  Maybe FilePath ->
+  FilePath ->
+  SessionM (Cradle Void, Either [CradleError] (ComponentOptions, FilePath, String))
+loadCradleWithNotifications recorder sessionState loadCradle hieYaml cfp = do
+  IdeTesting isTesting <- asks (optTesting . sessionIdeOptions)
+  sessionPref <- asks (sessionLoading . sessionClientConfig)
+  lspEnv <- asks sessionLspContext
+  rootDir <- asks sessionRootDir
+  let lfpLog = makeRelative rootDir cfp
+  logWith recorder Info $ LogCradlePath lfpLog
+  when (isNothing hieYaml) $
+    logWith recorder Warning $ LogCradleNotFound lfpLog
+  cradle <- liftIO $ loadCradle hieYaml rootDir
+  when isTesting $ mRunLspT lspEnv $
+    sendNotification (SMethod_CustomMethod (Proxy @"ghcide/cradle/loaded")) (toJSON cfp)
+
+  -- Display a user friendly progress message here: They probably don't know what a cradle is
+  let progMsg = "Setting up " <> T.pack (takeBaseName (cradleRootDir cradle))
+                <> " (for " <> T.pack lfpLog <> ")"
+
+  extraToLoads <- liftIO $ getExtraFilesToLoad sessionState cfp
+  eopts <- mRunLspTCallback lspEnv (\act -> withIndefiniteProgress progMsg Nothing NotCancellable (const act)) $
+    withTrace "Load cradle" $ \addTag -> do
+        addTag "file" lfpLog
+        res <- liftIO $ cradleToOptsAndLibDir recorder sessionPref cradle cfp extraToLoads
+        addTag "result" (show res)
+        return res
+  pure (cradle, eopts)
 
-    returnWithVersion $ \file -> do
-      -- see Note [Serializing runs in separate thread]
-      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
@@ -749,340 +988,26 @@ cradleToOptsAndLibDir recorder loadConfig cradle file old_fps = do
             PreferSingleComponentLoading -> LoadFile
             PreferMultiComponentLoading  -> LoadWithContext old_fps
 
-emptyHscEnv :: NameCache -> FilePath -> IO HscEnv
-emptyHscEnv nc libDir = do
-    -- We call setSessionDynFlags so that the loader is initialised
-    -- We need to do this before we call initUnits.
-    env <- runGhc (Just libDir) $
-      getSessionDynFlags >>= setSessionDynFlags >> getSession
-    pure $ setNameCache nc (hscSetFlags ((hsc_dflags env){useUnicode = True }) env)
-
-data TargetDetails = TargetDetails
-  {
-      targetTarget    :: !Target,
-      targetEnv       :: !(IdeResult HscEnvEq),
-      targetDepends   :: !DependencyInfo,
-      targetLocations :: ![NormalizedFilePath]
-  }
+-- ----------------------------------------------------------------------------
+-- Utilities
+-- ----------------------------------------------------------------------------
 
-fromTargetId :: [FilePath]          -- ^ import paths
-             -> [String]            -- ^ extensions to consider
-             -> TargetId
-             -> IdeResult HscEnvEq
-             -> DependencyInfo
-             -> IO [TargetDetails]
--- For a target module we consider all the import paths
-fromTargetId is exts (GHC.TargetModule modName) env dep = do
-    let fps = [i </> moduleNameSlashes modName -<.> ext <> boot
-              | ext <- exts
-              , i <- is
-              , boot <- ["", "-boot"]
-              ]
-    let locs = fmap toNormalizedFilePath' fps
-    return [TargetDetails (TargetModule modName) env dep locs]
--- For a 'TargetFile' we consider all the possible module names
-fromTargetId _ _ (GHC.TargetFile f _) env deps = do
-    let nf = toNormalizedFilePath' f
-    let other
-          | "-boot" `isSuffixOf` f = toNormalizedFilePath' (L.dropEnd 5 $ fromNormalizedFilePath nf)
-          | otherwise = toNormalizedFilePath' (fromNormalizedFilePath nf ++ "-boot")
-    return [TargetDetails (TargetFile nf) env deps [nf, other]]
+emptyHscEnvM :: FilePath -> SessionM HscEnv
+emptyHscEnvM libDir = do
+  nc <- asks sessionSharedNameCache
+  liftIO $ Ghc.emptyHscEnv nc libDir
 
 toFlagsMap :: TargetDetails -> [(NormalizedFilePath, (IdeResult HscEnvEq, DependencyInfo))]
 toFlagsMap TargetDetails{..} =
     [ (l, (targetEnv, targetDepends)) | l <-  targetLocations]
 
-
-setNameCache :: NameCache -> HscEnv -> HscEnv
-setNameCache nc hsc = hsc { hsc_NC = nc }
-
-#if MIN_VERSION_ghc(9,13,0)
--- Moved back to implementation in GHC.
-checkHomeUnitsClosed' ::  UnitEnv -> OS.Set UnitId -> [DriverMessages]
-checkHomeUnitsClosed' ue _ = checkHomeUnitsClosed ue
-#else
--- This function checks the important property that if both p and q are home units
--- then any dependency of p, which transitively depends on q is also a home unit.
--- GHC had an implementation of this function, but it was horribly inefficient
--- We should move back to the GHC implementation on compilers where
--- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/12162 is included
-checkHomeUnitsClosed' ::  UnitEnv -> OS.Set UnitId -> Maybe (Compat.MsgEnvelope DriverMessage)
-checkHomeUnitsClosed' ue home_id_set
-    | OS.null bad_unit_ids = Nothing
-    | otherwise = Just (GHC.mkPlainErrorMsgEnvelope rootLoc $ DriverHomePackagesNotClosed (OS.toList bad_unit_ids))
-  where
-    bad_unit_ids = upwards_closure OS.\\ home_id_set
-    rootLoc = mkGeneralSrcSpan (Compat.fsLit "<command line>")
-
-    graph :: Graph (Node UnitId UnitId)
-    graph = graphFromEdgedVerticesUniq graphNodes
-
-    -- downwards closure of graph
-    downwards_closure
-      = graphFromEdgedVerticesUniq [ DigraphNode uid uid (OS.toList deps)
-                                   | (uid, deps) <- Map.toList (allReachable graph node_key)]
-
-    inverse_closure = transposeG downwards_closure
-
-    upwards_closure = OS.fromList $ map node_key $ reachablesG inverse_closure [DigraphNode uid uid [] | uid <- OS.toList home_id_set]
-
-    all_unit_direct_deps :: UniqMap UnitId (OS.Set UnitId)
-    all_unit_direct_deps
-      = unitEnv_foldWithKey go emptyUniqMap $ ue_home_unit_graph ue
-      where
-        go rest this this_uis =
-           plusUniqMap_C OS.union
-             (addToUniqMap_C OS.union external_depends this (OS.fromList this_deps))
-             rest
-           where
-             external_depends = mapUniqMap (OS.fromList . unitDepends)
-#if !MIN_VERSION_ghc(9,7,0)
-                              $ listToUniqMap $ Map.toList
-#endif
-
-                              $ unitInfoMap this_units
-             this_units = homeUnitEnv_units this_uis
-             this_deps = [ Compat.toUnitId unit | (unit,Just _) <- explicitUnits this_units]
-
-    graphNodes :: [Node UnitId UnitId]
-    graphNodes = go OS.empty home_id_set
-      where
-        go done todo
-          = case OS.minView todo of
-              Nothing -> []
-              Just (uid, todo')
-                | OS.member uid done -> go done todo'
-                | otherwise -> case lookupUniqMap all_unit_direct_deps uid of
-                    Nothing -> pprPanic "uid not found" (Compat.ppr (uid, all_unit_direct_deps))
-                    Just depends ->
-                      let todo'' = (depends OS.\\ done) `OS.union` todo'
-                      in DigraphNode uid uid (OS.toList depends) : go (OS.insert uid done) todo''
-#endif
-
--- | Create a mapping from FilePaths to HscEnvEqs
--- This combines all the components we know about into
--- an appropriate session, which is a multi component
--- session on GHC 9.4+
-newComponentCache
-         :: Recorder (WithPriority Log)
-         -> [String]           -- ^ File extensions to consider
-         -> NormalizedFilePath -- ^ Path to file that caused the creation of this component
-         -> HscEnv             -- ^ An empty HscEnv
-         -> [ComponentInfo]    -- ^ New components to be loaded
-         -> [ComponentInfo]    -- ^ old, already existing components
-         -> IO [ [TargetDetails] ]
-newComponentCache recorder exts _cfp hsc_env old_cis new_cis = do
-    let cis = Map.unionWith unionCIs (mkMap new_cis) (mkMap old_cis)
-        -- When we have multiple components with the same uid,
-        -- prefer the new one over the old.
-        -- However, we might have added some targets to the old unit
-        -- (see special target), so preserve those
-        unionCIs new_ci old_ci = new_ci { componentTargets = componentTargets new_ci ++ componentTargets old_ci }
-        mkMap = Map.fromListWith unionCIs . map (\ci -> (componentUnitId ci, ci))
-    let dfs = map componentDynFlags $ Map.elems cis
-        uids = Map.keys cis
-    logWith recorder Info $ LogMakingNewHscEnv uids
-    hscEnv' <- -- Set up a multi component session with the other units on GHC 9.4
-              Compat.initUnits dfs hsc_env
-
-    let closure_errs = maybeToList $ checkHomeUnitsClosed' (hsc_unit_env hscEnv') (hsc_all_home_unit_ids hscEnv')
-        closure_err_to_multi_err err =
-            ideErrorWithSource
-                (Just "cradle") (Just DiagnosticSeverity_Warning) _cfp
-                (T.pack (Compat.printWithoutUniques (singleMessage err)))
-                (Just (fmap GhcDriverMessage err))
-        multi_errs = map closure_err_to_multi_err closure_errs
-        bad_units = OS.fromList $ concat $ do
-            x <- map errMsgDiagnostic closure_errs
-            DriverHomePackagesNotClosed us <- pure x
-            pure us
-        isBad ci = (homeUnitId_ (componentDynFlags ci)) `OS.member` bad_units
-    -- Whenever we spin up a session on Linux, dynamically load libm.so.6
-    -- in. We need this in case the binary is statically linked, in which
-    -- case the interactive session will fail when trying to load
-    -- ghc-prim, which happens whenever Template Haskell is being
-    -- evaluated or haskell-language-server's eval plugin tries to run
-    -- some code. If the binary is dynamically linked, then this will have
-    -- no effect.
-    -- See https://github.com/haskell/haskell-language-server/issues/221
-    -- We need to do this after the call to setSessionDynFlags initialises
-    -- the loader
-    when (os == "linux") $ do
-      initObjLinker hscEnv'
-      res <- loadDLL hscEnv' "libm.so.6"
-      case res of
-        Nothing  -> pure ()
-        Just err -> logWith recorder Error $ LogDLLLoadError err
-
-    forM (Map.elems cis) $ \ci -> do
-      let df = componentDynFlags ci
-      thisEnv <- do
-            -- In GHC 9.4 we have multi component support, and we have initialised all the units
-            -- above.
-            -- We just need to set the current unit here
-            pure $ hscSetActiveUnitId (homeUnitId_ df) hscEnv'
-      henv <- newHscEnvEq thisEnv
-      let targetEnv = (if isBad ci then multi_errs else [], Just henv)
-          targetDepends = componentDependencyInfo ci
-      logWith recorder Debug $ LogNewComponentCache (targetEnv, targetDepends)
-      evaluate $ liftRnf rwhnf $ componentTargets ci
-
-      let mk t = fromTargetId (importPaths df) exts (targetId t) targetEnv targetDepends
-      ctargets <- concatMapM mk (componentTargets ci)
-
-      return (L.nubOrdOn targetTarget ctargets)
-
-{- Note [Avoiding bad interface files]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Originally, we set the cache directory for the various components once
-on the first occurrence of the component.
-This works fine if these components have no references to each other,
-but you have components that depend on each other, the interface files are
-updated for each component.
-After restarting the session and only opening the component that depended
-on the other, suddenly the interface files of this component are stale.
-However, from the point of view of `ghcide`, they do not look stale,
-thus, not regenerated and the IDE shows weird errors such as:
-```
-typecheckIface
-Declaration for Rep_ClientRunFlags
-Axiom branches Rep_ClientRunFlags:
-  Failed to load interface for ‘Distribution.Simple.Flag’
-  Use -v to see a list of the files searched for.
-```
-and
-```
-expectJust checkFamInstConsistency
-CallStack (from HasCallStack):
-  error, called at compiler\\utils\\Maybes.hs:55:27 in ghc:Maybes
-  expectJust, called at compiler\\typecheck\\FamInst.hs:461:30 in ghc:FamInst
-```
-
-and many more.
-
-To mitigate this, we set the cache directory for each component dependent
-on the components of the current `HscEnv`, additionally to the component options
-of the respective components.
-Assume two components, c1, c2, where c2 depends on c1, and the options of the
-respective components are co1, co2.
-If we want to load component c2, followed by c1, we set the cache directory for
-each component in this way:
-
-  * Load component c2
-    * (Cache Directory State)
-        - name of c2 + co2
-  * Load component c1
-    * (Cache Directory State)
-        - name of c2 + name of c1 + co2
-        - name of c2 + name of c1 + co1
-
-Overall, we created three cache directories. If we opened c1 first, then we
-create a fourth cache directory.
-This makes sure that interface files are always correctly updated.
-
-Since this causes a lot of recompilation, we only update the cache-directory,
-if the dependencies of a component have really changed.
-E.g. when you load two executables, they can not depend on each other. They
-should be filtered out, such that we dont have to re-compile everything.
--}
-
--- | Set the cache-directory based on the ComponentOptions and a list of
--- internal packages.
--- For the exact reason, see Note [Avoiding bad interface files].
-setCacheDirs :: MonadUnliftIO m => Recorder (WithPriority Log) -> CacheDirs -> DynFlags -> m DynFlags
-setCacheDirs recorder CacheDirs{..} dflags = do
-    logWith recorder Info $ LogInterfaceFilesCacheDir (fromMaybe cacheDir hiCacheDir)
-    pure $ dflags
-          & maybe id setHiDir hiCacheDir
-          & maybe id setHieDir hieCacheDir
-          & maybe id setODir oCacheDir
-
 -- See Note [Multi Cradle Dependency Info]
-type DependencyInfo = Map.Map FilePath (Maybe UTCTime)
 type HieMap = Map.Map (Maybe FilePath) [RawComponentInfo]
 -- | Maps a "hie.yaml" location to all its Target Filepaths and options.
-type FlagsMap = Map.Map (Maybe FilePath) (HM.HashMap NormalizedFilePath (IdeResult HscEnvEq, DependencyInfo))
+type FlagsMap = STM.Map (Maybe FilePath) (HM.HashMap NormalizedFilePath (IdeResult HscEnvEq, DependencyInfo))
 -- | Maps a Filepath to its respective "hie.yaml" location.
 -- It aims to be the reverse of 'FlagsMap'.
-type FilesMap = HM.HashMap NormalizedFilePath (Maybe FilePath)
-
--- This is pristine information about a component
-data RawComponentInfo = RawComponentInfo
-  { rawComponentUnitId         :: UnitId
-  -- | Unprocessed DynFlags. Contains inplace packages such as libraries.
-  -- We do not want to use them unprocessed.
-  , rawComponentDynFlags       :: DynFlags
-  -- | All targets of this components.
-  , rawComponentTargets        :: [GHC.Target]
-  -- | Filepath which caused the creation of this component
-  , rawComponentFP             :: NormalizedFilePath
-  -- | Component Options used to load the component.
-  , rawComponentCOptions       :: ComponentOptions
-  -- | Maps cradle dependencies, such as `stack.yaml`, or `.cabal` file
-  -- to last modification time. See Note [Multi Cradle Dependency Info].
-  , rawComponentDependencyInfo :: DependencyInfo
-  }
-
--- This is processed information about the component, in particular the dynflags will be modified.
-data ComponentInfo = ComponentInfo
-  { componentUnitId         :: UnitId
-  -- | Processed DynFlags. Does not contain inplace packages such as local
-  -- libraries. Can be used to actually load this Component.
-  , componentDynFlags       :: DynFlags
-  -- | All targets of this components.
-  , componentTargets        :: [GHC.Target]
-  -- | Filepath which caused the creation of this component
-  , componentFP             :: NormalizedFilePath
-  -- | Component Options used to load the component.
-  , componentCOptions       :: ComponentOptions
-  -- | Maps cradle dependencies, such as `stack.yaml`, or `.cabal` file
-  -- to last modification time. See Note [Multi Cradle Dependency Info]
-  , componentDependencyInfo :: DependencyInfo
-  }
-
--- | Check if any dependency has been modified lately.
-checkDependencyInfo :: DependencyInfo -> IO Bool
-checkDependencyInfo old_di = do
-  di <- getDependencyInfo (Map.keys old_di)
-  return (di == old_di)
-
--- Note [Multi Cradle Dependency Info]
--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--- Why do we implement our own file modification tracking here?
--- The primary reason is that the custom caching logic is quite complicated and going into shake
--- adds even more complexity and more indirection. I did try for about 5 hours to work out how to
--- use shake rules rather than IO but eventually gave up.
-
--- | Computes a mapping from a filepath to its latest modification date.
--- See Note [Multi Cradle Dependency Info] why we do this ourselves instead
--- of letting shake take care of it.
-getDependencyInfo :: [FilePath] -> IO DependencyInfo
-getDependencyInfo fs = Map.fromList <$> mapM do_one fs
-
-  where
-    safeTryIO :: IO a -> IO (Either IOException a)
-    safeTryIO = Safe.try
-
-    do_one :: FilePath -> IO (FilePath, Maybe UTCTime)
-    do_one fp = (fp,) . eitherToMaybe <$> safeTryIO (getModificationTime fp)
-
--- | This function removes all the -package flags which refer to packages we
--- are going to deal with ourselves. For example, if a executable depends
--- on a library component, then this function will remove the library flag
--- from the package flags for the executable
---
--- There are several places in GHC (for example the call to hptInstances in
--- tcRnImports) which assume that all modules in the HPT have the same unit
--- ID. Therefore we create a fake one and give them all the same unit id.
-_removeInplacePackages --Only used in ghc < 9.4
-    :: UnitId     -- ^ fake uid to use for our internal component
-    -> [UnitId]
-    -> DynFlags
-    -> (DynFlags, [UnitId])
-_removeInplacePackages fake_uid us df = (setHomeUnitId_ fake_uid $
-                                       df { packageFlags = ps }, uids)
-  where
-    (uids, ps) = Compat.filterInplaceUnits us (packageFlags df)
+type FilesMap = STM.Map NormalizedFilePath (Maybe FilePath)
 
 -- | Memoize an IO function, with the characteristics:
 --
@@ -1101,131 +1026,6 @@ memoIO op = do
                 return (Map.insert k res mp, res)
             Just res -> return (mp, res)
 
-unit_flags :: [Flag (CmdLineP [String])]
-unit_flags = [defFlag "unit"  (SepArg addUnit)]
-
-addUnit :: String -> EwM (CmdLineP [String]) ()
-addUnit unit_str = liftEwM $ do
-  units <- getCmdLineState
-  putCmdLineState (unit_str : units)
-
--- | Throws if package flags are unsatisfiable
-setOptions :: GhcMonad m
-    => OptHaddockParse
-    -> NormalizedFilePath
-    -> ComponentOptions
-    -> DynFlags
-    -> FilePath -- ^ root dir, see Note [Root Directory]
-    -> m (NonEmpty (DynFlags, [GHC.Target]))
-setOptions haddockOpt cfp (ComponentOptions theOpts compRoot _) dflags rootDir = do
-    ((theOpts',_errs,_warns),units) <- processCmdLineP unit_flags [] (map noLoc theOpts)
-    case NE.nonEmpty units of
-      Just us -> initMulti us
-      Nothing -> do
-        (df, targets) <- initOne (map unLoc theOpts')
-        -- A special target for the file which caused this wonderful
-        -- component to be created. In case the cradle doesn't list all the targets for
-        -- the component, in which case things will be horribly broken anyway.
-        --
-        -- When we have a singleComponent that is caused to be loaded due to a
-        -- file, we assume the file is part of that component. This is useful
-        -- for bare GHC sessions, such as many of the ones used in the testsuite
-        --
-        -- We don't do this when we have multiple components, because each
-        -- component better list all targets or there will be anarchy.
-        -- It is difficult to know which component to add our file to in
-        -- that case.
-        -- Multi unit arguments are likely to come from cabal, which
-        -- does list all targets.
-        --
-        -- If we don't end up with a target for the current file in the end, then
-        -- we will report it as an error for that file
-        let abs_fp = toAbsolute rootDir (fromNormalizedFilePath cfp)
-        let special_target = Compat.mkSimpleTarget df abs_fp
-        pure $ (df, special_target : targets) :| []
-    where
-      initMulti unitArgFiles =
-        forM unitArgFiles $ \f -> do
-          args <- liftIO $ expandResponse [f]
-          -- The reponse files may contain arguments like "+RTS",
-          -- and hie-bios doesn't expand the response files of @-unit@ arguments.
-          -- Thus, we need to do the stripping here.
-          initOne $ HieBios.removeRTS $ HieBios.removeVerbosityOpts args
-      initOne this_opts = do
-        (dflags', targets') <- addCmdOpts this_opts dflags
-        let dflags'' =
-                case unitIdString (homeUnitId_ dflags') of
-                     -- cabal uses main for the unit id of all executable packages
-                     -- This makes multi-component sessions confused about what
-                     -- options to use for that component.
-                     -- Solution: hash the options and use that as part of the unit id
-                     -- This works because there won't be any dependencies on the
-                     -- executable unit.
-                     "main" ->
-                       let hash = B.unpack $ B16.encode $ H.finalize $ H.updates H.init (map B.pack this_opts)
-                           hashed_uid = Compat.toUnitId (Compat.stringToUnit ("main-"++hash))
-                       in setHomeUnitId_ hashed_uid dflags'
-                     _ -> dflags'
-
-        let targets = makeTargetsAbsolute root targets'
-            root = case workingDirectory dflags'' of
-              Nothing   -> compRoot
-              Just wdir -> compRoot </> wdir
-        let dflags''' =
-              setWorkingDirectory root $
-              disableWarningsAsErrors $
-              -- disabled, generated directly by ghcide instead
-              flip gopt_unset Opt_WriteInterface $
-              -- disabled, generated directly by ghcide instead
-              -- also, it can confuse the interface stale check
-              dontWriteHieFiles $
-              setIgnoreInterfacePragmas $
-              setBytecodeLinkerOptions $
-              enableOptHaddock haddockOpt $
-              disableOptimisation $
-              Compat.setUpTypedHoles $
-              makeDynFlagsAbsolute compRoot -- makeDynFlagsAbsolute already accounts for workingDirectory
-              dflags''
-        return (dflags''', targets)
-
-setIgnoreInterfacePragmas :: DynFlags -> DynFlags
-setIgnoreInterfacePragmas df =
-    gopt_set (gopt_set df Opt_IgnoreInterfacePragmas) Opt_IgnoreOptimChanges
-
-disableOptimisation :: DynFlags -> DynFlags
-disableOptimisation df = updOptLevel 0 df
-
--- | We always compile with '-haddock' unless explicitly disabled.
---
--- This avoids inconsistencies when doing recompilation checking which was
--- observed in https://github.com/haskell/haskell-language-server/issues/4511
-enableOptHaddock :: OptHaddockParse -> DynFlags -> DynFlags
-enableOptHaddock HaddockParse d   = gopt_set d Opt_Haddock
-enableOptHaddock NoHaddockParse d = d
-
-setHiDir :: FilePath -> DynFlags -> DynFlags
-setHiDir f d =
-    -- override user settings to avoid conflicts leading to recompilation
-    d { hiDir      = Just f}
-
-setODir :: FilePath -> DynFlags -> DynFlags
-setODir f d =
-    -- override user settings to avoid conflicts leading to recompilation
-    d { objectDir = Just f}
-
-getCacheDirsDefault :: String -> [String] -> IO CacheDirs
-getCacheDirsDefault prefix opts = do
-    dir <- Just <$> getXdgDirectory XdgCache (cacheDir </> prefix ++ "-" ++ opts_hash)
-    return $ CacheDirs dir dir dir
-    where
-        -- Create a unique folder per set of different GHC options, assuming that each different set of
-        -- GHC options will create incompatible interface files.
-        opts_hash = B.unpack $ B16.encode $ H.finalize $ H.updates H.init (map B.pack opts)
-
--- | Sub directory for the cache path
-cacheDir :: String
-cacheDir = "ghcide"
-
 ----------------------------------------------------------------------------------------------------
 
 data PackageSetupException
@@ -1236,7 +1036,7 @@ data PackageSetupException
         { compileTime :: !Version
         , runTime     :: !Version
         }
-    deriving (Eq, Show, Typeable)
+    deriving (Eq, Show)
 
 instance Exception PackageSetupException
 
diff --git a/ghcide/session-loader/Development/IDE/Session/Dependency.hs b/ghcide/session-loader/Development/IDE/Session/Dependency.hs
new file mode 100644
index 0000000000..deedf809b8
--- /dev/null
+++ b/ghcide/session-loader/Development/IDE/Session/Dependency.hs
@@ -0,0 +1,35 @@
+module Development.IDE.Session.Dependency where
+
+import           Control.Exception.Safe as Safe
+import           Data.Either.Extra
+import qualified Data.Map.Strict        as Map
+import           Data.Time.Clock
+import           System.Directory
+
+type DependencyInfo = Map.Map FilePath (Maybe UTCTime)
+
+-- | Check if any dependency has been modified lately.
+checkDependencyInfo :: DependencyInfo -> IO Bool
+checkDependencyInfo old_di = do
+  di <- getDependencyInfo (Map.keys old_di)
+  return (di == old_di)
+
+-- Note [Multi Cradle Dependency Info]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Why do we implement our own file modification tracking here?
+-- The primary reason is that the custom caching logic is quite complicated and going into shake
+-- adds even more complexity and more indirection. I did try for about 5 hours to work out how to
+-- use shake rules rather than IO but eventually gave up.
+
+-- | Computes a mapping from a filepath to its latest modification date.
+-- See Note [Multi Cradle Dependency Info] why we do this ourselves instead
+-- of letting shake take care of it.
+getDependencyInfo :: [FilePath] -> IO DependencyInfo
+getDependencyInfo fs = Map.fromList <$> mapM do_one fs
+
+  where
+    safeTryIO :: IO a -> IO (Either IOException a)
+    safeTryIO = Safe.try
+
+    do_one :: FilePath -> IO (FilePath, Maybe UTCTime)
+    do_one fp = (fp,) . eitherToMaybe <$> safeTryIO (getModificationTime fp)
diff --git a/ghcide/session-loader/Development/IDE/Session/Ghc.hs b/ghcide/session-loader/Development/IDE/Session/Ghc.hs
new file mode 100644
index 0000000000..7a84263ec9
--- /dev/null
+++ b/ghcide/session-loader/Development/IDE/Session/Ghc.hs
@@ -0,0 +1,540 @@
+{-# LANGUAGE CPP #-}
+module Development.IDE.Session.Ghc where
+
+import           Control.Monad
+import           Control.Monad.Extra                as Extra
+import           Control.Monad.IO.Class
+import qualified Crypto.Hash.SHA1                   as H
+import qualified Data.ByteString.Base16             as B16
+import qualified Data.ByteString.Char8              as B
+import           Data.Function
+import           Data.List
+import           Data.List.Extra                    as L
+import           Data.List.NonEmpty                 (NonEmpty (..))
+import qualified Data.List.NonEmpty                 as NE
+import qualified Data.Map.Strict                    as Map
+import           Data.Maybe
+import qualified Data.Text                          as T
+import           Development.IDE.Core.Shake         hiding (Log, knownTargets,
+                                                     withHieDb)
+import qualified Development.IDE.GHC.Compat         as Compat
+import           Development.IDE.GHC.Compat.CmdLine
+import           Development.IDE.GHC.Compat.Core    hiding (Target, TargetFile,
+                                                     TargetModule, Var, Warning,
+                                                     getOptions)
+import qualified Development.IDE.GHC.Compat.Core    as GHC
+import           Development.IDE.GHC.Compat.Env     hiding (Logger)
+import           Development.IDE.GHC.Compat.Units   (UnitId)
+import           Development.IDE.GHC.Util
+import           Development.IDE.Types.Diagnostics
+import           Development.IDE.Types.HscEnvEq     (HscEnvEq, newHscEnvEq)
+import           Development.IDE.Types.Location
+import           GHC.ResponseFile
+import qualified HIE.Bios.Cradle.Utils              as HieBios
+import           HIE.Bios.Environment               hiding (getCacheDir)
+import           HIE.Bios.Types                     hiding (Log)
+import           Ide.Logger                         (Pretty (pretty),
+                                                     Priority (Debug, Error, Info),
+                                                     Recorder, WithPriority,
+                                                     logWith, viaShow, (<+>))
+import           System.Directory
+import           System.FilePath
+import           System.Info
+
+
+import           Control.DeepSeq
+import           Control.Exception                  (evaluate)
+import           Control.Monad.IO.Unlift            (MonadUnliftIO)
+import qualified Data.Set                           as OS
+import qualified Development.IDE.GHC.Compat.Util    as Compat
+import           Development.IDE.Session.Dependency
+import           Development.IDE.Types.Options
+import           GHC.Data.Graph.Directed
+import           Ide.PluginUtils                    (toAbsolute)
+
+import           GHC.Driver.Env                     (hsc_all_home_unit_ids)
+import           GHC.Driver.Errors.Types
+import           GHC.Types.Error                    (errMsgDiagnostic,
+                                                     singleMessage)
+import           GHC.Unit.State
+
+data Log
+  = LogInterfaceFilesCacheDir !FilePath
+  | LogMakingNewHscEnv ![UnitId]
+  | LogNewComponentCache !(([FileDiagnostic], Maybe HscEnvEq), DependencyInfo)
+  | LogDLLLoadError !String
+deriving instance Show Log
+
+instance Pretty Log where
+  pretty = \case
+    LogInterfaceFilesCacheDir path ->
+      "Interface files cache directory:" <+> pretty path
+    LogMakingNewHscEnv inPlaceUnitIds ->
+      "Making new HscEnv. In-place unit ids:" <+> pretty (map show inPlaceUnitIds)
+    LogNewComponentCache componentCache ->
+      "New component cache HscEnvEq:" <+> viaShow componentCache
+    LogDLLLoadError errorString ->
+      "Error dynamically loading libm.so.6:" <+> pretty errorString
+
+-- This is pristine information about a component
+data RawComponentInfo = RawComponentInfo
+  { rawComponentUnitId         :: UnitId
+  -- | Unprocessed DynFlags. Contains inplace packages such as libraries.
+  -- We do not want to use them unprocessed.
+  , rawComponentDynFlags       :: DynFlags
+  -- | All targets of this components.
+  , rawComponentTargets        :: [GHC.Target]
+  -- | Filepath which caused the creation of this component
+  , rawComponentFP             :: NormalizedFilePath
+  -- | Component Options used to load the component.
+  , rawComponentCOptions       :: ComponentOptions
+  -- | Maps cradle dependencies, such as `stack.yaml`, or `.cabal` file
+  -- to last modification time. See Note [Multi Cradle Dependency Info].
+  , rawComponentDependencyInfo :: DependencyInfo
+  }
+
+-- This is processed information about the component, in particular the dynflags will be modified.
+data ComponentInfo = ComponentInfo
+  { componentUnitId         :: UnitId
+  -- | Processed DynFlags. Does not contain inplace packages such as local
+  -- libraries. Can be used to actually load this Component.
+  , componentDynFlags       :: DynFlags
+  -- | All targets of this components.
+  , componentTargets        :: [GHC.Target]
+  -- | Filepath which caused the creation of this component
+  , componentFP             :: NormalizedFilePath
+  -- | Component Options used to load the component.
+  , componentCOptions       :: ComponentOptions
+  -- | Maps cradle dependencies, such as `stack.yaml`, or `.cabal` file
+  -- to last modification time. See Note [Multi Cradle Dependency Info]
+  , componentDependencyInfo :: DependencyInfo
+  }
+
+
+unit_flags :: [Flag (CmdLineP [String])]
+unit_flags = [defFlag "unit"  (SepArg addUnit)]
+
+addUnit :: String -> EwM (CmdLineP [String]) ()
+addUnit unit_str = liftEwM $ do
+  units <- getCmdLineState
+  putCmdLineState (unit_str : units)
+
+
+-- | Create a mapping from FilePaths to HscEnvEqs
+-- This combines all the components we know about into
+-- an appropriate session, which is a multi component
+-- session on GHC 9.4+
+newComponentCache
+         :: Recorder (WithPriority Log)
+         -> [String]           -- ^ File extensions to consider
+         -> NormalizedFilePath -- ^ Path to file that caused the creation of this component
+         -> HscEnv             -- ^ An empty HscEnv
+         -> [ComponentInfo]    -- ^ New components to be loaded
+         -> [ComponentInfo]    -- ^ old, already existing components
+         -> IO [ [TargetDetails] ]
+newComponentCache recorder exts _cfp hsc_env old_cis new_cis = do
+    let cis = Map.unionWith unionCIs (mkMap new_cis) (mkMap old_cis)
+        -- When we have multiple components with the same uid,
+        -- prefer the new one over the old.
+        -- However, we might have added some targets to the old unit
+        -- (see special target), so preserve those
+        unionCIs new_ci old_ci = new_ci { componentTargets = componentTargets new_ci ++ componentTargets old_ci }
+        mkMap = Map.fromListWith unionCIs . map (\ci -> (componentUnitId ci, ci))
+    let dfs = map componentDynFlags $ Map.elems cis
+        uids = Map.keys cis
+    logWith recorder Info $ LogMakingNewHscEnv uids
+    hscEnv' <- -- Set up a multi component session with the other units on GHC 9.4
+              Compat.initUnits dfs hsc_env
+
+    let closure_errs = maybeToList $ checkHomeUnitsClosed' (hsc_unit_env hscEnv') (hsc_all_home_unit_ids hscEnv')
+        closure_err_to_multi_err err =
+            ideErrorWithSource
+                (Just "cradle") (Just DiagnosticSeverity_Warning) _cfp
+                (T.pack (Compat.printWithoutUniques (singleMessage err)))
+                (Just (fmap GhcDriverMessage err))
+        multi_errs = map closure_err_to_multi_err closure_errs
+        bad_units = OS.fromList $ concat $ do
+            x <- map errMsgDiagnostic closure_errs
+            DriverHomePackagesNotClosed us <- pure x
+            pure us
+        isBad ci = (homeUnitId_ (componentDynFlags ci)) `OS.member` bad_units
+    -- Whenever we spin up a session on Linux, dynamically load libm.so.6
+    -- in. We need this in case the binary is statically linked, in which
+    -- case the interactive session will fail when trying to load
+    -- ghc-prim, which happens whenever Template Haskell is being
+    -- evaluated or haskell-language-server's eval plugin tries to run
+    -- some code. If the binary is dynamically linked, then this will have
+    -- no effect.
+    -- See https://github.com/haskell/haskell-language-server/issues/221
+    -- We need to do this after the call to setSessionDynFlags initialises
+    -- the loader
+    when (os == "linux") $ do
+      initObjLinker hscEnv'
+      res <- loadDLL hscEnv' "libm.so.6"
+      case res of
+        Nothing  -> pure ()
+        Just err -> logWith recorder Error $ LogDLLLoadError err
+
+    forM (Map.elems cis) $ \ci -> do
+      let df = componentDynFlags ci
+      thisEnv <- do
+            -- In GHC 9.4 we have multi component support, and we have initialised all the units
+            -- above.
+            -- We just need to set the current unit here
+            pure $ hscSetActiveUnitId (homeUnitId_ df) hscEnv'
+      henv <- newHscEnvEq thisEnv
+      let targetEnv = (if isBad ci then multi_errs else [], Just henv)
+          targetDepends = componentDependencyInfo ci
+      logWith recorder Debug $ LogNewComponentCache (targetEnv, targetDepends)
+      evaluate $ liftRnf rwhnf $ componentTargets ci
+
+      let mk t = fromTargetId (importPaths df) exts (targetId t) targetEnv targetDepends
+      ctargets <- concatMapM mk (componentTargets ci)
+
+      return (L.nubOrdOn targetTarget ctargets)
+
+-- | Throws if package flags are unsatisfiable
+setOptions :: GhcMonad m
+    => OptHaddockParse
+    -> NormalizedFilePath
+    -> ComponentOptions
+    -> DynFlags
+    -> FilePath -- ^ root dir, see Note [Root Directory]
+    -> m (NonEmpty (DynFlags, [GHC.Target]))
+setOptions haddockOpt cfp (ComponentOptions theOpts compRoot _) dflags rootDir = do
+    ((theOpts',_errs,_warns),units) <- processCmdLineP unit_flags [] (map noLoc theOpts)
+    case NE.nonEmpty units of
+      Just us -> initMulti us
+      Nothing -> do
+        (df, targets) <- initOne (map unLoc theOpts')
+        -- A special target for the file which caused this wonderful
+        -- component to be created. In case the cradle doesn't list all the targets for
+        -- the component, in which case things will be horribly broken anyway.
+        --
+        -- When we have a singleComponent that is caused to be loaded due to a
+        -- file, we assume the file is part of that component. This is useful
+        -- for bare GHC sessions, such as many of the ones used in the testsuite
+        --
+        -- We don't do this when we have multiple components, because each
+        -- component better list all targets or there will be anarchy.
+        -- It is difficult to know which component to add our file to in
+        -- that case.
+        -- Multi unit arguments are likely to come from cabal, which
+        -- does list all targets.
+        --
+        -- If we don't end up with a target for the current file in the end, then
+        -- we will report it as an error for that file
+        let abs_fp = toAbsolute rootDir (fromNormalizedFilePath cfp)
+        let special_target = Compat.mkSimpleTarget df abs_fp
+        pure $ (df, special_target : targets) :| []
+    where
+      initMulti unitArgFiles =
+        forM unitArgFiles $ \f -> do
+          args <- liftIO $ expandResponse [f]
+          -- The reponse files may contain arguments like "+RTS",
+          -- and hie-bios doesn't expand the response files of @-unit@ arguments.
+          -- Thus, we need to do the stripping here.
+          initOne $ HieBios.removeRTS $ HieBios.removeVerbosityOpts args
+      initOne this_opts = do
+        (dflags', targets') <- addCmdOpts this_opts dflags
+        let dflags'' =
+                case unitIdString (homeUnitId_ dflags') of
+                     -- cabal uses main for the unit id of all executable packages
+                     -- This makes multi-component sessions confused about what
+                     -- options to use for that component.
+                     -- Solution: hash the options and use that as part of the unit id
+                     -- This works because there won't be any dependencies on the
+                     -- executable unit.
+                     "main" ->
+                       let hash = B.unpack $ B16.encode $ H.finalize $ H.updates H.init (map B.pack this_opts)
+                           hashed_uid = Compat.toUnitId (Compat.stringToUnit ("main-"++hash))
+                       in setHomeUnitId_ hashed_uid dflags'
+                     _ -> dflags'
+
+        let targets = makeTargetsAbsolute root targets'
+            root = case workingDirectory dflags'' of
+              Nothing   -> compRoot
+              Just wdir -> compRoot </> wdir
+        let dflags''' =
+              setWorkingDirectory root $
+              disableWarningsAsErrors $
+              -- disabled, generated directly by ghcide instead
+              flip gopt_unset Opt_WriteInterface $
+              -- disabled, generated directly by ghcide instead
+              -- also, it can confuse the interface stale check
+              dontWriteHieFiles $
+              setIgnoreInterfacePragmas $
+              setBytecodeLinkerOptions $
+              enableOptHaddock haddockOpt $
+              disableOptimisation $
+              Compat.setUpTypedHoles $
+              makeDynFlagsAbsolute compRoot -- makeDynFlagsAbsolute already accounts for workingDirectory
+              dflags''
+        return (dflags''', targets)
+
+addComponentInfo ::
+  MonadUnliftIO m =>
+  Recorder (WithPriority Log) ->
+  (String -> [String] -> IO CacheDirs) ->
+  DependencyInfo ->
+  NonEmpty (DynFlags, [GHC.Target]) ->
+  (Maybe FilePath, NormalizedFilePath, ComponentOptions) ->
+  Map.Map (Maybe FilePath) [RawComponentInfo] ->
+  m (Map.Map (Maybe FilePath) [RawComponentInfo], ([ComponentInfo], [ComponentInfo]))
+addComponentInfo recorder getCacheDirs dep_info newDynFlags (hieYaml, cfp, opts) m = do
+  -- Just deps if there's already an HscEnv
+  -- Nothing is it's the first time we are making an HscEnv
+  let oldDeps = Map.lookup hieYaml m
+  let -- Add the raw information about this component to the list
+      -- We will modify the unitId and DynFlags used for
+      -- compilation but these are the true source of
+      -- information.
+      new_deps = fmap (\(df, targets) -> RawComponentInfo (homeUnitId_ df) df targets cfp opts dep_info) newDynFlags
+      all_deps = new_deps `NE.appendList` fromMaybe [] oldDeps
+      -- Get all the unit-ids for things in this component
+
+  all_deps' <- forM all_deps $ \RawComponentInfo{..} -> do
+    let prefix = show rawComponentUnitId
+    -- See Note [Avoiding bad interface files]
+    let cacheDirOpts = componentOptions opts
+    cacheDirs <- liftIO $ getCacheDirs prefix cacheDirOpts
+    processed_df <- setCacheDirs recorder cacheDirs rawComponentDynFlags
+    -- The final component information, mostly the same but the DynFlags don't
+    -- contain any packages which are also loaded
+    -- into the same component.
+    pure $ ComponentInfo
+      { componentUnitId = rawComponentUnitId
+      , componentDynFlags = processed_df
+      , componentTargets = rawComponentTargets
+      , componentFP = rawComponentFP
+      , componentCOptions = rawComponentCOptions
+      , componentDependencyInfo = rawComponentDependencyInfo
+      }
+  -- Modify the map so the hieYaml now maps to the newly updated
+  -- ComponentInfos
+  -- Returns
+  -- . The information for the new component which caused this cache miss
+  -- . The modified information (without -inplace flags) for
+  --   existing packages
+  let (new,old) = NE.splitAt (NE.length new_deps) all_deps'
+  pure (Map.insert hieYaml (NE.toList all_deps) m, (new,old))
+
+setIgnoreInterfacePragmas :: DynFlags -> DynFlags
+setIgnoreInterfacePragmas df =
+    gopt_set (gopt_set df Opt_IgnoreInterfacePragmas) Opt_IgnoreOptimChanges
+
+disableOptimisation :: DynFlags -> DynFlags
+disableOptimisation df = updOptLevel 0 df
+
+-- | We always compile with '-haddock' unless explicitly disabled.
+--
+-- This avoids inconsistencies when doing recompilation checking which was
+-- observed in https://github.com/haskell/haskell-language-server/issues/4511
+enableOptHaddock :: OptHaddockParse -> DynFlags -> DynFlags
+enableOptHaddock HaddockParse d   = gopt_set d Opt_Haddock
+enableOptHaddock NoHaddockParse d = d
+
+setHiDir :: FilePath -> DynFlags -> DynFlags
+setHiDir f d =
+    -- override user settings to avoid conflicts leading to recompilation
+    d { hiDir      = Just f}
+
+setODir :: FilePath -> DynFlags -> DynFlags
+setODir f d =
+    -- override user settings to avoid conflicts leading to recompilation
+    d { objectDir = Just f}
+
+data CacheDirs = CacheDirs
+  { hiCacheDir, hieCacheDir, oCacheDir :: Maybe FilePath}
+
+{- Note [Avoiding bad interface files]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Originally, we set the cache directory for the various components once
+on the first occurrence of the component.
+This works fine if these components have no references to each other,
+but you have components that depend on each other, the interface files are
+updated for each component.
+After restarting the session and only opening the component that depended
+on the other, suddenly the interface files of this component are stale.
+However, from the point of view of `ghcide`, they do not look stale,
+thus, not regenerated and the IDE shows weird errors such as:
+```
+typecheckIface
+Declaration for Rep_ClientRunFlags
+Axiom branches Rep_ClientRunFlags:
+  Failed to load interface for ‘Distribution.Simple.Flag’
+  Use -v to see a list of the files searched for.
+```
+and
+```
+expectJust checkFamInstConsistency
+CallStack (from HasCallStack):
+  error, called at compiler\\utils\\Maybes.hs:55:27 in ghc:Maybes
+  expectJust, called at compiler\\typecheck\\FamInst.hs:461:30 in ghc:FamInst
+```
+
+and many more.
+
+To mitigate this, we set the cache directory for each component dependent
+on the components of the current `HscEnv`, additionally to the component options
+of the respective components.
+Assume two components, c1, c2, where c2 depends on c1, and the options of the
+respective components are co1, co2.
+If we want to load component c2, followed by c1, we set the cache directory for
+each component in this way:
+
+  * Load component c2
+    * (Cache Directory State)
+        - name of c2 + co2
+  * Load component c1
+    * (Cache Directory State)
+        - name of c2 + name of c1 + co2
+        - name of c2 + name of c1 + co1
+
+Overall, we created three cache directories. If we opened c1 first, then we
+create a fourth cache directory.
+This makes sure that interface files are always correctly updated.
+
+Since this causes a lot of recompilation, we only update the cache-directory,
+if the dependencies of a component have really changed.
+E.g. when you load two executables, they can not depend on each other. They
+should be filtered out, such that we dont have to re-compile everything.
+-}
+
+
+-- | Set the cache-directory based on the ComponentOptions and a list of
+-- internal packages.
+-- For the exact reason, see Note [Avoiding bad interface files].
+setCacheDirs :: MonadUnliftIO m => Recorder (WithPriority Log) -> CacheDirs -> DynFlags -> m DynFlags
+setCacheDirs recorder CacheDirs{..} dflags = do
+    logWith recorder Info $ LogInterfaceFilesCacheDir (fromMaybe cacheDir hiCacheDir)
+    pure $ dflags
+          & maybe id setHiDir hiCacheDir
+          & maybe id setHieDir hieCacheDir
+          & maybe id setODir oCacheDir
+
+getCacheDirsDefault :: String -> [String] -> IO CacheDirs
+getCacheDirsDefault prefix opts = do
+    dir <- Just <$> getXdgDirectory XdgCache (cacheDir </> prefix ++ "-" ++ opts_hash)
+    return $ CacheDirs dir dir dir
+    where
+        -- Create a unique folder per set of different GHC options, assuming that each different set of
+        -- GHC options will create incompatible interface files.
+        opts_hash = B.unpack $ B16.encode $ H.finalize $ H.updates H.init (map B.pack opts)
+
+setNameCache :: NameCache -> HscEnv -> HscEnv
+setNameCache nc hsc = hsc { hsc_NC = nc }
+
+-- | Sub directory for the cache path
+cacheDir :: String
+cacheDir = "ghcide"
+
+emptyHscEnv :: NameCache -> FilePath -> IO HscEnv
+emptyHscEnv nc libDir = do
+    -- We call setSessionDynFlags so that the loader is initialised
+    -- We need to do this before we call initUnits.
+    env <- liftIO $ runGhc (Just libDir) $
+      getSessionDynFlags >>= setSessionDynFlags >> getSession
+    pure $ setNameCache nc (hscSetFlags ((hsc_dflags env){useUnicode = True }) env)
+
+-- ----------------------------------------------------------------------------
+-- Target Details
+-- ----------------------------------------------------------------------------
+
+data TargetDetails = TargetDetails
+  {
+      targetTarget    :: !Target,
+      targetEnv       :: !(IdeResult HscEnvEq),
+      targetDepends   :: !DependencyInfo,
+      targetLocations :: ![NormalizedFilePath]
+  }
+
+fromTargetId :: [FilePath]          -- ^ import paths
+             -> [String]            -- ^ extensions to consider
+             -> TargetId
+             -> IdeResult HscEnvEq
+             -> DependencyInfo
+             -> IO [TargetDetails]
+-- For a target module we consider all the import paths
+fromTargetId is exts (GHC.TargetModule modName) env dep = do
+    let fps = [i </> moduleNameSlashes modName -<.> ext <> boot
+              | ext <- exts
+              , i <- is
+              , boot <- ["", "-boot"]
+              ]
+    let locs = fmap toNormalizedFilePath' fps
+    return [TargetDetails (TargetModule modName) env dep locs]
+-- For a 'TargetFile' we consider all the possible module names
+fromTargetId _ _ (GHC.TargetFile f _) env deps = do
+    let nf = toNormalizedFilePath' f
+    let other
+          | "-boot" `isSuffixOf` f = toNormalizedFilePath' (L.dropEnd 5 $ fromNormalizedFilePath nf)
+          | otherwise = toNormalizedFilePath' (fromNormalizedFilePath nf ++ "-boot")
+    return [TargetDetails (TargetFile nf) env deps [nf, other]]
+
+-- ----------------------------------------------------------------------------
+-- Backwards compatibility
+-- ----------------------------------------------------------------------------
+
+#if MIN_VERSION_ghc(9,13,0)
+-- Moved back to implementation in GHC.
+checkHomeUnitsClosed' ::  UnitEnv -> OS.Set UnitId -> [DriverMessages]
+checkHomeUnitsClosed' ue _ = checkHomeUnitsClosed ue
+#else
+-- This function checks the important property that if both p and q are home units
+-- then any dependency of p, which transitively depends on q is also a home unit.
+-- GHC had an implementation of this function, but it was horribly inefficient
+-- We should move back to the GHC implementation on compilers where
+-- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/12162 is included
+checkHomeUnitsClosed' ::  UnitEnv -> OS.Set UnitId -> Maybe (Compat.MsgEnvelope DriverMessage)
+checkHomeUnitsClosed' ue home_id_set
+    | OS.null bad_unit_ids = Nothing
+    | otherwise = Just (GHC.mkPlainErrorMsgEnvelope rootLoc $ DriverHomePackagesNotClosed (OS.toList bad_unit_ids))
+  where
+    bad_unit_ids = upwards_closure OS.\\ home_id_set
+    rootLoc = mkGeneralSrcSpan (Compat.fsLit "<command line>")
+
+    graph :: Graph (Node UnitId UnitId)
+    graph = graphFromEdgedVerticesUniq graphNodes
+
+    -- downwards closure of graph
+    downwards_closure
+      = graphFromEdgedVerticesUniq [ DigraphNode uid uid (OS.toList deps)
+                                   | (uid, deps) <- Map.toList (allReachable graph node_key)]
+
+    inverse_closure = transposeG downwards_closure
+
+    upwards_closure = OS.fromList $ map node_key $ reachablesG inverse_closure [DigraphNode uid uid [] | uid <- OS.toList home_id_set]
+
+    all_unit_direct_deps :: UniqMap UnitId (OS.Set UnitId)
+    all_unit_direct_deps
+      = unitEnv_foldWithKey go emptyUniqMap $ ue_home_unit_graph ue
+      where
+        go rest this this_uis =
+           plusUniqMap_C OS.union
+             (addToUniqMap_C OS.union external_depends this (OS.fromList this_deps))
+             rest
+           where
+             external_depends = mapUniqMap (OS.fromList . unitDepends)
+#if !MIN_VERSION_ghc(9,7,0)
+                              $ listToUniqMap $ Map.toList
+#endif
+
+                              $ unitInfoMap this_units
+             this_units = homeUnitEnv_units this_uis
+             this_deps = [ Compat.toUnitId unit | (unit,Just _) <- explicitUnits this_units]
+
+    graphNodes :: [Node UnitId UnitId]
+    graphNodes = go OS.empty home_id_set
+      where
+        go done todo
+          = case OS.minView todo of
+              Nothing -> []
+              Just (uid, todo')
+                | OS.member uid done -> go done todo'
+                | otherwise -> case lookupUniqMap all_unit_direct_deps uid of
+                    Nothing -> pprPanic "uid not found" (Compat.ppr (uid, all_unit_direct_deps))
+                    Just depends ->
+                      let todo'' = (depends OS.\\ done) `OS.union` todo'
+                      in DigraphNode uid uid (OS.toList depends) : go (OS.insert uid done) todo''
+#endif
diff --git a/ghcide/session-loader/Development/IDE/Session/OrderedSet.hs b/ghcide/session-loader/Development/IDE/Session/OrderedSet.hs
new file mode 100644
index 0000000000..630f1dc4fc
--- /dev/null
+++ b/ghcide/session-loader/Development/IDE/Session/OrderedSet.hs
@@ -0,0 +1,54 @@
+module Development.IDE.Session.OrderedSet where
+
+import           Control.Concurrent.STM        (STM, TQueue, newTQueueIO)
+import           Control.Concurrent.STM.TQueue (readTQueue, writeTQueue)
+import           Control.Monad                 (when)
+import           Data.Hashable                 (Hashable)
+import qualified Data.HashSet
+import qualified Focus
+import qualified ListT                         as LT
+import qualified StmContainers.Set             as S
+import           StmContainers.Set             (Set)
+
+
+data OrderedSet a = OrderedSet
+  { insertionOrder :: TQueue a
+  , elements       :: Set a
+  }
+
+-- | Insert an element into the ordered set.
+-- If the element is not already present, it is added to both the queue and set.
+-- If the element already exists, ignore it
+insert :: Hashable a => a -> OrderedSet a -> STM ()
+insert a (OrderedSet que s) = do
+    (_, inserted) <- S.focus (Focus.testingIfInserts $ Focus.insert ()) a s
+    -- if already in the set
+    when inserted $ writeTQueue que a
+
+newIO :: Hashable a => IO (OrderedSet a)
+newIO = do
+    que <- newTQueueIO
+    s <- S.newIO
+    return (OrderedSet que s)
+
+-- | Read the first element from the queue.
+-- If an element is not in the set, it means it has been deleted,
+-- so we retry until we find a valid element that exists in the set.
+readQueue :: Hashable a => OrderedSet a -> STM a
+readQueue rs@(OrderedSet que s) = do
+                f <- readTQueue que
+                b <- S.lookup f s
+                -- retry if no files are left in the queue
+                if b then return f else readQueue rs
+
+lookup :: Hashable a => a -> OrderedSet a -> STM Bool
+lookup a (OrderedSet _ s) = S.lookup a s
+
+-- | Delete an element from the set.
+-- The queue is not modified directly; stale entries are filtered out lazily
+-- during reading operations (see 'readQueue').
+delete :: Hashable a => a -> OrderedSet a -> STM ()
+delete a (OrderedSet _ s) = S.delete a s
+
+toHashSet :: Hashable a => OrderedSet a -> STM (Data.HashSet.HashSet a)
+toHashSet (OrderedSet _ s) = Data.HashSet.fromList <$> LT.toList (S.listT s)
diff --git a/ghcide/src/Development/IDE/Core/Actions.hs b/ghcide/src/Development/IDE/Core/Actions.hs
index 61614cb0ca..f8d9d4b2b2 100644
--- a/ghcide/src/Development/IDE/Core/Actions.hs
+++ b/ghcide/src/Development/IDE/Core/Actions.hs
@@ -63,7 +63,7 @@ getAtPoint file pos = runMaybeT $ do
 
   (hf, mapping) <- useWithStaleFastMT GetHieAst file
   env <- hscEnv . fst <$> useWithStaleFastMT GhcSession file
-  dkMap <- lift $ maybe (DKMap mempty mempty) fst <$> runMaybeT (useWithStaleFastMT GetDocMap file)
+  dkMap <- lift $ maybe (DKMap mempty mempty mempty) fst <$> runMaybeT (useWithStaleFastMT GetDocMap file)
 
   !pos' <- MaybeT (return $ fromCurrentPosition mapping pos)
   MaybeT $ liftIO $ fmap (first (toCurrentRange mapping =<<)) <$> AtPoint.atPoint opts hf dkMap env pos'
diff --git a/ghcide/src/Development/IDE/Core/Compile.hs b/ghcide/src/Development/IDE/Core/Compile.hs
index 48439e2ff3..2b25fb08c0 100644
--- a/ghcide/src/Development/IDE/Core/Compile.hs
+++ b/ghcide/src/Development/IDE/Core/Compile.hs
@@ -114,11 +114,15 @@ import qualified GHC.Runtime.Loader                           as Loader
 import           GHC.Tc.Gen.Splice
 import           GHC.Types.Error
 import           GHC.Types.ForeignStubs
-import           GHC.Types.HpcInfo
 import           GHC.Types.TypeEnv
+import           Development.IDE.WorkerThread (writeTaskQueue)
 
 -- See Note [Guidelines For Using CPP In GHCIDE Import Statements]
 
+#if !MIN_VERSION_ghc(9,11,0)
+import           GHC.Types.HpcInfo
+#endif
+
 #if MIN_VERSION_ghc(9,7,0)
 import           Data.Foldable                                (toList)
 import           GHC.Unit.Module.Warnings
@@ -793,7 +797,8 @@ atomicFileWrite se targetPath write = do
   let dir = takeDirectory targetPath
   createDirectoryIfMissing True dir
   (tempFilePath, cleanUp) <- newTempFileWithin dir
-  (write tempFilePath >>= \x -> renameFile tempFilePath targetPath >> atomically (resetInterfaceStore se (toNormalizedFilePath' targetPath)) >> pure x)
+  (write tempFilePath >>= \x -> renameFile tempFilePath targetPath >>
+    atomically (resetInterfaceStore se (toNormalizedFilePath' targetPath)) >> pure x)
     `onException` cleanUp
 
 generateHieAsts :: HscEnv -> TcModuleResult
@@ -882,7 +887,7 @@ indexHieFile se mod_summary srcPath !hash hf = do
       -- hiedb doesn't use the Haskell src, so we clear it to avoid unnecessarily keeping it around
       let !hf' = hf{hie_hs_src = mempty}
       modifyTVar' indexPending $ HashMap.insert srcPath hash
-      writeTQueue indexQueue $ \withHieDb -> do
+      writeTaskQueue indexQueue $ \withHieDb -> do
         -- We are now in the worker thread
         -- Check if a newer index of this file has been scheduled, and if so skip this one
         newerScheduled <- atomically $ do
diff --git a/ghcide/src/Development/IDE/Core/FileStore.hs b/ghcide/src/Development/IDE/Core/FileStore.hs
index e545ec7b14..0bdec3874e 100644
--- a/ghcide/src/Development/IDE/Core/FileStore.hs
+++ b/ghcide/src/Development/IDE/Core/FileStore.hs
@@ -25,7 +25,6 @@ module Development.IDE.Core.FileStore(
     ) where
 
 import           Control.Concurrent.STM.Stats                 (STM, atomically)
-import           Control.Concurrent.STM.TQueue                (writeTQueue)
 import           Control.Exception
 import           Control.Lens                                 ((^.))
 import           Control.Monad.Extra
@@ -52,6 +51,7 @@ import           Development.IDE.Types.Diagnostics
 import           Development.IDE.Types.Location
 import           Development.IDE.Types.Options
 import           Development.IDE.Types.Shake                  (toKey)
+import           Development.IDE.WorkerThread                 (writeTaskQueue)
 import           HieDb.Create                                 (deleteMissingRealFiles)
 import           Ide.Logger                                   (Pretty (pretty),
                                                                Priority (Info),
@@ -109,7 +109,7 @@ addWatchedFileRule recorder isWatched = defineNoDiagnostics (cmapWithPrio LogSha
 
 
 getModificationTimeRule :: Recorder (WithPriority Log) -> Rules ()
-getModificationTimeRule recorder = defineEarlyCutoff (cmapWithPrio LogShake recorder) $ Rule $ \(GetModificationTime_ missingFileDiags) file ->
+getModificationTimeRule recorder = defineEarlyCutoff (cmapWithPrio LogShake recorder) $ Rule $ \(GetModificationTime_ missingFileDiags) file -> do
     getModificationTimeImpl missingFileDiags file
 
 getModificationTimeImpl
@@ -252,8 +252,8 @@ getVersionedTextDoc doc = do
     maybe (pure Nothing) getVirtualFile $
         uriToNormalizedFilePath $ toNormalizedUri uri
   let ver = case mvf of
-        Just (VirtualFile lspver _ _) -> lspver
-        Nothing                       -> 0
+        Just (VirtualFile lspver _ _ _) -> lspver
+        Nothing                         -> 0
   return (VersionedTextDocumentIdentifier uri ver)
 
 fileStoreRules :: Recorder (WithPriority Log) -> (NormalizedFilePath -> Action Bool) -> Rules ()
@@ -279,11 +279,9 @@ setFileModified recorder vfs state saved nfp actionBefore = do
           AlwaysCheck -> True
           CheckOnSave -> saved
           _           -> False
-    restartShakeSession (shakeExtras state) vfs (fromNormalizedFilePath nfp ++ " (modified)") [] $ do
+    restartShakeSession (shakeExtras state) vfs (fromNormalizedFilePath nfp ++ " (modified)") ([mkDelayedAction "ParentTC" L.Debug (typecheckParentsAction recorder nfp) | checkParents]) $ do
         keys<-actionBefore
         return (toKey GetModificationTime nfp:keys)
-    when checkParents $
-      typecheckParents recorder state nfp
 
 typecheckParents :: Recorder (WithPriority Log) -> IdeState -> NormalizedFilePath -> IO ()
 typecheckParents recorder state nfp = void $ shakeEnqueue (shakeExtras state) parents
@@ -295,7 +293,7 @@ typecheckParentsAction recorder nfp = do
     case revs of
       Nothing -> logWith recorder Info $ LogCouldNotIdentifyReverseDeps nfp
       Just rs -> do
-        logWith recorder Info $ LogTypeCheckingReverseDeps nfp revs
+        logWith recorder L.Debug $ LogTypeCheckingReverseDeps nfp revs
         void $ uses GetModIface rs
 
 -- | Note that some keys have been modified and restart the session
@@ -304,7 +302,7 @@ typecheckParentsAction recorder nfp = do
 setSomethingModified :: VFSModified -> IdeState -> String -> IO [Key] -> IO ()
 setSomethingModified vfs state reason actionBetweenSession = do
     -- Update database to remove any files that might have been renamed/deleted
-    atomically $ writeTQueue (indexQueue $ hiedbWriter $ shakeExtras state) (\withHieDb -> withHieDb deleteMissingRealFiles)
+    atomically $ writeTaskQueue (indexQueue $ hiedbWriter $ shakeExtras state) (\withHieDb -> withHieDb deleteMissingRealFiles)
     void $ restartShakeSession (shakeExtras state) vfs reason [] actionBetweenSession
 
 registerFileWatches :: [String] -> LSP.LspT Config IO Bool
diff --git a/ghcide/src/Development/IDE/Core/PluginUtils.hs b/ghcide/src/Development/IDE/Core/PluginUtils.hs
index 6ba633df26..ca404b0dd0 100644
--- a/ghcide/src/Development/IDE/Core/PluginUtils.hs
+++ b/ghcide/src/Development/IDE/Core/PluginUtils.hs
@@ -88,11 +88,11 @@ useMT :: IdeRule k v => k -> NormalizedFilePath -> MaybeT Action v
 useMT k = MaybeT . Shake.use k
 
 -- |ExceptT version of `uses` that throws a PluginRuleFailed upon failure
-usesE :: (Traversable f, IdeRule k v) => k -> f NormalizedFilePath -> ExceptT PluginError Action (f v)
+usesE :: (IdeRule k v) => k -> [NormalizedFilePath] -> ExceptT PluginError Action [v]
 usesE k = maybeToExceptT (PluginRuleFailed (T.pack $ show k)) . usesMT k
 
 -- |MaybeT version of `uses`
-usesMT :: (Traversable f, IdeRule k v) => k -> f NormalizedFilePath -> MaybeT Action (f v)
+usesMT :: (IdeRule k v) => k -> [NormalizedFilePath] -> MaybeT Action [v]
 usesMT k xs = MaybeT $ sequence <$> Shake.uses k xs
 
 -- |ExceptT version of `useWithStale` that throws a PluginRuleFailed upon
@@ -104,7 +104,9 @@ useWithStaleE key = maybeToExceptT (PluginRuleFailed (T.pack $ show key)) . useW
 -- |MaybeT version of `useWithStale`
 useWithStaleMT :: IdeRule k v
     => k -> NormalizedFilePath -> MaybeT Action (v, PositionMapping)
-useWithStaleMT key file = MaybeT $ runIdentity <$> Shake.usesWithStale key (Identity file)
+useWithStaleMT key file = MaybeT $ do
+    [r] <- Shake.usesWithStale key [file]
+    return r
 
 -- ----------------------------------------------------------------------------
 -- IdeAction wrappers
diff --git a/ghcide/src/Development/IDE/Core/RuleTypes.hs b/ghcide/src/Development/IDE/Core/RuleTypes.hs
index a13e6de14c..8798068b45 100644
--- a/ghcide/src/Development/IDE/Core/RuleTypes.hs
+++ b/ghcide/src/Development/IDE/Core/RuleTypes.hs
@@ -253,9 +253,15 @@ type instance RuleResult GetHieAst = HieAstResult
 -- | A IntervalMap telling us what is in scope at each point
 type instance RuleResult GetBindings = Bindings
 
-data DocAndTyThingMap = DKMap {getDocMap :: !DocMap, getTyThingMap :: !TyThingMap}
+data DocAndTyThingMap = DKMap
+    { getDocMap     :: !DocMap
+    -- ^ Docs for declarations: functions, data types, instances, methods, etc
+    , getTyThingMap :: !TyThingMap
+    , getArgDocMap  :: !ArgDocMap
+    -- ^ Docs for arguments, e.g., function arguments and method arguments
+    }
 instance NFData DocAndTyThingMap where
-    rnf (DKMap a b) = rwhnf a `seq` rwhnf b
+    rnf (DKMap a b c) = rwhnf a `seq` rwhnf b `seq` rwhnf c
 
 instance Show DocAndTyThingMap where
     show = const "docmap"
diff --git a/ghcide/src/Development/IDE/Core/Rules.hs b/ghcide/src/Development/IDE/Core/Rules.hs
index c123c9d4a8..d07cfda0d8 100644
--- a/ghcide/src/Development/IDE/Core/Rules.hs
+++ b/ghcide/src/Development/IDE/Core/Rules.hs
@@ -516,8 +516,8 @@ persistentHieFileRule recorder = addPersistentRule GetHieAst $ \file -> runMaybe
   vfsRef <- asks vfsVar
   vfsData <- liftIO $ _vfsMap <$> readTVarIO vfsRef
   (currentSource, ver) <- liftIO $ case M.lookup (filePathToUri' file) vfsData of
-    Nothing -> (,Nothing) . T.decodeUtf8 <$> BS.readFile (fromNormalizedFilePath file)
-    Just vf -> pure (virtualFileText vf, Just $ virtualFileVersion vf)
+    Just (Open vf) -> pure (virtualFileText vf, Just $ virtualFileVersion vf)
+    _ -> (,Nothing) . T.decodeUtf8 <$> BS.readFile (fromNormalizedFilePath file)
   let refmap = generateReferencesMap . getAsts . Compat.hie_asts $ res
       del = deltaFromDiff (T.decodeUtf8 $ Compat.hie_hs_src res) currentSource
   pure (HAR (Compat.hie_module res) (Compat.hie_asts res) refmap mempty (HieFromDisk res),del,ver)
@@ -582,7 +582,7 @@ getDocMapRule recorder =
 
 -- | Persistent rule to ensure that hover doesn't block on startup
 persistentDocMapRule :: Rules ()
-persistentDocMapRule = addPersistentRule GetDocMap $ \_ -> pure $ Just (DKMap mempty mempty, idDelta, Nothing)
+persistentDocMapRule = addPersistentRule GetDocMap $ \_ -> pure $ Just (DKMap mempty mempty mempty, idDelta, Nothing)
 
 readHieFileForSrcFromDisk :: Recorder (WithPriority Log) -> NormalizedFilePath -> MaybeT IdeAction Compat.HieFile
 readHieFileForSrcFromDisk recorder file = do
@@ -722,7 +722,7 @@ loadGhcSession recorder ghcSessionDepsConfig = do
                 itExists <- getFileExists nfp
                 when itExists $ void $ do
                   use_ GetPhysicalModificationTime nfp
-        logWith recorder Logger.Info $ LogDependencies file deps
+        logWith recorder Logger.Debug $ LogDependencies file deps
         mapM_ addDependency deps
 
         let cutoffHash = LBS.toStrict $ B.encode (hash (snd val))
diff --git a/ghcide/src/Development/IDE/Core/Shake.hs b/ghcide/src/Development/IDE/Core/Shake.hs
index 6fc9a4d00e..7473482fd4 100644
--- a/ghcide/src/Development/IDE/Core/Shake.hs
+++ b/ghcide/src/Development/IDE/Core/Shake.hs
@@ -25,7 +25,7 @@ module Development.IDE.Core.Shake(
     IdeState, shakeSessionInit, shakeExtras, shakeDb, rootDir,
     ShakeExtras(..), getShakeExtras, getShakeExtrasRules,
     KnownTargets(..), Target(..), toKnownFiles, unionKnownTargets, mkKnownTargets,
-    IdeRule, IdeResult,
+    IdeRule, IdeResult, RestartQueue,
     GetModificationTime(GetModificationTime, GetModificationTime_, missingFileDiagnostics),
     shakeOpen, shakeShut,
     shakeEnqueue,
@@ -81,113 +81,126 @@ module Development.IDE.Core.Shake(
 
 import           Control.Concurrent.Async
 import           Control.Concurrent.STM
-import           Control.Concurrent.STM.Stats           (atomicallyNamed)
+import           Control.Concurrent.STM.Stats            (atomicallyNamed)
 import           Control.Concurrent.Strict
 import           Control.DeepSeq
-import           Control.Exception.Extra                hiding (bracket_)
-import           Control.Lens                           ((%~), (&), (?~))
+import           Control.Exception.Extra                 hiding (bracket_)
+import           Control.Lens                            ((%~), (&), (?~))
 import           Control.Monad.Extra
 import           Control.Monad.IO.Class
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Maybe
-import           Data.Aeson                             (Result (Success),
-                                                         toJSON)
-import qualified Data.Aeson.Types                       as A
-import qualified Data.ByteString.Char8                  as BS
-import qualified Data.ByteString.Char8                  as BS8
-import           Data.Coerce                            (coerce)
+import           Data.Aeson                              (Result (Success),
+                                                          toJSON)
+import qualified Data.Aeson.Types                        as A
+import qualified Data.ByteString.Char8                   as BS
+import qualified Data.ByteString.Char8                   as BS8
+import           Data.Coerce                             (coerce)
 import           Data.Default
 import           Data.Dynamic
-import           Data.EnumMap.Strict                    (EnumMap)
-import qualified Data.EnumMap.Strict                    as EM
-import           Data.Foldable                          (find, for_)
-import           Data.Functor                           ((<&>))
+import           Data.EnumMap.Strict                     (EnumMap)
+import qualified Data.EnumMap.Strict                     as EM
+import           Data.Foldable                           (find, for_)
+import           Data.Functor                            ((<&>))
 import           Data.Functor.Identity
 import           Data.Hashable
-import qualified Data.HashMap.Strict                    as HMap
-import           Data.HashSet                           (HashSet)
-import qualified Data.HashSet                           as HSet
-import           Data.List.Extra                        (foldl', partition,
-                                                         takeEnd)
-import qualified Data.Map.Strict                        as Map
+import qualified Data.HashMap.Strict                     as HMap
+import           Data.HashSet                            (HashSet)
+import qualified Data.HashSet                            as HSet
+import           Data.List.Extra                         (foldl', partition,
+                                                          takeEnd)
+import qualified Data.Map.Strict                         as Map
 import           Data.Maybe
-import qualified Data.SortedList                        as SL
-import           Data.String                            (fromString)
-import qualified Data.Text                              as T
+import qualified Data.SortedList                         as SL
+import           Data.String                             (fromString)
+import qualified Data.Text                               as T
 import           Data.Time
 import           Data.Traversable
 import           Data.Tuple.Extra
 import           Data.Typeable
 import           Data.Unique
-import           Data.Vector                            (Vector)
-import qualified Data.Vector                            as Vector
+import           Data.Vector                             (Vector)
+import qualified Data.Vector                             as Vector
 import           Development.IDE.Core.Debouncer
-import           Development.IDE.Core.FileUtils         (getModTime)
+import           Development.IDE.Core.FileUtils          (getModTime)
 import           Development.IDE.Core.PositionMapping
 import           Development.IDE.Core.ProgressReporting
 import           Development.IDE.Core.RuleTypes
-import           Development.IDE.Types.Options          as Options
-import qualified Language.LSP.Protocol.Message          as LSP
-import qualified Language.LSP.Server                    as LSP
+import           Development.IDE.Types.Options           as Options
+import qualified Language.LSP.Protocol.Message           as LSP
+import qualified Language.LSP.Server                     as LSP
 
+import           Data.Either                             (isRight, lefts)
+import           Data.Int                                (Int64)
+import           Data.IORef.Extra                        (atomicModifyIORef'_)
 import           Development.IDE.Core.Tracing
-import           Development.IDE.Core.WorkerThread
-import           Development.IDE.GHC.Compat             (NameCache,
-                                                         NameCacheUpdater,
-                                                         initNameCache,
-                                                         knownKeyNames)
-import           Development.IDE.GHC.Orphans            ()
-import           Development.IDE.Graph                  hiding (ShakeValue,
-                                                         action)
-import qualified Development.IDE.Graph                  as Shake
-import           Development.IDE.Graph.Database         (ShakeDatabase,
-                                                         shakeGetBuildStep,
-                                                         shakeGetDatabaseKeys,
-                                                         shakeNewDatabase,
-                                                         shakeProfileDatabase,
-                                                         shakeRunDatabaseForKeys)
+import           Development.IDE.GHC.Compat              (NameCache,
+                                                          NameCacheUpdater,
+                                                          initNameCache,
+                                                          knownKeyNames)
+import           Development.IDE.GHC.Orphans             ()
+import           Development.IDE.Graph                   hiding (ShakeValue,
+                                                          action)
+import qualified Development.IDE.Graph                   as Shake
+import           Development.IDE.Graph.Database          (ShakeDatabase,
+                                                          shakeGetActionQueueLength,
+                                                          shakeGetBuildStep,
+                                                          shakeGetDatabaseKeys,
+                                                          shakeNewDatabase,
+                                                          shakeProfileDatabase,
+                                                          shakeRunDatabaseForKeysSep,
+                                                          shakeShutDatabase)
+import           Development.IDE.Graph.Internal.Action   (runActionInDbCb)
+import           Development.IDE.Graph.Internal.Database (AsyncParentKill (AsyncParentKill))
+import           Development.IDE.Graph.Internal.Types    (Step (..),
+                                                          getShakeStep)
 import           Development.IDE.Graph.Rule
 import           Development.IDE.Types.Action
 import           Development.IDE.Types.Diagnostics
-import           Development.IDE.Types.Exports          hiding (exportsMapSize)
-import qualified Development.IDE.Types.Exports          as ExportsMap
+import           Development.IDE.Types.Exports           hiding (exportsMapSize)
+import qualified Development.IDE.Types.Exports           as ExportsMap
 import           Development.IDE.Types.KnownTargets
 import           Development.IDE.Types.Location
-import           Development.IDE.Types.Monitoring       (Monitoring (..))
+import           Development.IDE.Types.Monitoring        (Monitoring (..))
 import           Development.IDE.Types.Shake
+import           Development.IDE.WorkerThread
 import qualified Focus
+import           GHC.Base                                (undefined)
 import           GHC.Fingerprint
-import           GHC.Stack                              (HasCallStack)
-import           GHC.TypeLits                           (KnownSymbol)
+import           GHC.Stack                               (HasCallStack)
+import           GHC.TypeLits                            (KnownSymbol)
 import           HieDb.Types
-import           Ide.Logger                             hiding (Priority)
-import qualified Ide.Logger                             as Logger
+import           Ide.Logger                              hiding (Priority)
+import qualified Ide.Logger                              as Logger
 import           Ide.Plugin.Config
-import qualified Ide.PluginUtils                        as HLS
+import qualified Ide.PluginUtils                         as HLS
 import           Ide.Types
-import qualified Language.LSP.Protocol.Lens             as L
+import qualified Language.LSP.Protocol.Lens              as L
 import           Language.LSP.Protocol.Message
 import           Language.LSP.Protocol.Types
-import qualified Language.LSP.Protocol.Types            as LSP
-import           Language.LSP.VFS                       hiding (start)
+import qualified Language.LSP.Protocol.Types             as LSP
+import           Language.LSP.VFS                        hiding (start)
 import qualified "list-t" ListT
-import           OpenTelemetry.Eventlog                 hiding (addEvent)
-import qualified Prettyprinter                          as Pretty
-import qualified StmContainers.Map                      as STM
-import           System.FilePath                        hiding (makeRelative)
-import           System.IO.Unsafe                       (unsafePerformIO)
+import           OpenTelemetry.Eventlog                  hiding (addEvent)
+import qualified Prettyprinter                           as Pretty
+import qualified StmContainers.Map                       as STM
+import           System.FilePath                         hiding (makeRelative)
+import           System.IO.Unsafe                        (unsafePerformIO)
 import           System.Time.Extra
-import           UnliftIO                               (MonadUnliftIO (withRunInIO))
+import           UnliftIO                                (MonadUnliftIO (withRunInIO),
+                                                          newIORef, readIORef)
+
 
 
 data Log
   = LogCreateHieDbExportsMapStart
   | LogCreateHieDbExportsMapFinish !Int
-  | LogBuildSessionRestart !String ![DelayedActionInternal] !KeySet !Seconds !(Maybe FilePath)
+  | LogBuildSessionRestart !String ![DelayedActionInternal] !KeySet !Seconds !(Maybe FilePath) !Int
   | LogBuildSessionRestartTakingTooLong !Seconds
   | LogDelayedAction !(DelayedAction ()) !Seconds
-  | LogBuildSessionFinish !(Maybe SomeException)
+  | LogBuildSessionFinish !Step !(Either SomeException [Either SomeException ()])
   | LogDiagsDiffButNoLspEnv ![FileDiagnostic]
+  | LogDiagsPublishLog !Key ![FileDiagnostic] ![FileDiagnostic]
   | LogDefineEarlyCutoffRuleNoDiagHasDiag !FileDiagnostic
   | LogDefineEarlyCutoffRuleCustomNewnessHasDiag !FileDiagnostic
   | LogCancelledAction !T.Text
@@ -196,19 +209,31 @@ data Log
   | LogShakeGarbageCollection !T.Text !Int !Seconds
   -- * OfInterest Log messages
   | LogSetFilesOfInterest ![(NormalizedFilePath, FileOfInterestStatus)]
+  | LogShakeText !T.Text
+  | LogMonitering !T.Text !Int64
   deriving Show
 
 instance Pretty Log where
   pretty = \case
+    LogMonitering name value ->
+      "Monitoring:" <+> pretty name <+> "value:" <+> pretty value
+    LogDiagsPublishLog key lastDiags diags ->
+        vcat
+            [ "Publishing diagnostics for" <+> pretty (show key)
+            , "Last published:" <+> pretty (showDiagnosticsColored lastDiags) <+> "diagnostics"
+            , "New:" <+> pretty (showDiagnosticsColored diags) <+> "diagnostics"
+            ]
+    LogShakeText msg -> pretty msg
     LogCreateHieDbExportsMapStart ->
       "Initializing exports map from hiedb"
     LogCreateHieDbExportsMapFinish exportsMapSize ->
       "Done initializing exports map from hiedb. Size:" <+> pretty exportsMapSize
-    LogBuildSessionRestart reason actionQueue keyBackLog abortDuration shakeProfilePath ->
+    LogBuildSessionRestart reason actionQueue keyBackLog abortDuration shakeProfilePath step ->
       vcat
         [ "Restarting build session due to" <+> pretty reason
         , "Action Queue:" <+> pretty (map actionName actionQueue)
         , "Keys:" <+> pretty (map show $ toListKeySet keyBackLog)
+        , "Current step:" <+> pretty (show step)
         , "Aborting previous build session took" <+> pretty (showDuration abortDuration) <+> pretty shakeProfilePath ]
     LogBuildSessionRestartTakingTooLong seconds ->
         "Build restart is taking too long (" <> pretty seconds <> " seconds)"
@@ -216,10 +241,18 @@ instance Pretty Log where
       hsep
         [ "Finished:" <+> pretty (actionName delayedAct)
         , "Took:" <+> pretty (showDuration seconds) ]
-    LogBuildSessionFinish e ->
+    LogBuildSessionFinish step e ->
       vcat
         [ "Finished build session"
-        , pretty (fmap displayException e) ]
+        , "Step:" <+> pretty (show step)
+        , "Result:" <+> case e of
+            Left ex -> "Exception:" <+> pretty (show ex)
+            Right rs ->
+              if all isRight rs then
+                "Success"
+              else
+                "Exceptions in actions:" <+> pretty (fmap displayException $ lefts rs)
+        ]
     LogDiagsDiffButNoLspEnv fileDiagnostics ->
       "updateFileDiagnostics published different from new diagnostics - file diagnostics:"
       <+> pretty (showDiagnosticsColored fileDiagnostics)
@@ -254,12 +287,15 @@ data HieDbWriter
 -- | Actions to queue up on the index worker thread
 -- The inner `(HieDb -> IO ()) -> IO ()` wraps `HieDb -> IO ()`
 -- with (currently) retry functionality
-type IndexQueue = TQueue (((HieDb -> IO ()) -> IO ()) -> IO ())
+type IndexQueue = TaskQueue (((HieDb -> IO ()) -> IO ()) -> IO ())
+type RestartQueue = TaskQueue (IO ())
+type LoaderQueue = TaskQueue (IO ())
+
 
 data ThreadQueue = ThreadQueue {
     tIndexQueue     :: IndexQueue
-    , tRestartQueue :: TQueue (IO ())
-    , tLoaderQueue  :: TQueue (IO ())
+    , tRestartQueue :: RestartQueue
+    , tLoaderQueue  :: LoaderQueue
 }
 
 -- Note [Semantic Tokens Cache Location]
@@ -279,7 +315,7 @@ data ShakeExtras = ShakeExtras
     ,globals :: TVar (HMap.HashMap TypeRep Dynamic)
       -- ^ Registry of global state used by rules.
       -- Small and immutable after startup, so not worth using an STM.Map.
-    ,state :: Values
+    ,stateValues :: Values
     ,diagnostics :: STMDiagnosticStore
     ,hiddenDiagnostics :: STMDiagnosticStore
     ,publishedDiagnostics :: STM.Map NormalizedUri [FileDiagnostic]
@@ -330,9 +366,9 @@ data ShakeExtras = ShakeExtras
       -- ^ Default HLS config, only relevant if the client does not provide any Config
     , dirtyKeys :: TVar KeySet
       -- ^ Set of dirty rule keys since the last Shake run
-    , restartQueue :: TQueue (IO ())
+    , restartQueue :: RestartQueue
       -- ^ Queue of restart actions to be run.
-    , loaderQueue :: TQueue (IO ())
+    , loaderQueue :: LoaderQueue
       -- ^ Queue of loader actions to be run.
     }
 
@@ -390,11 +426,17 @@ addPersistentRule k getVal = do
 
 class Typeable a => IsIdeGlobal a where
 
+-- data VirtualFileEntry = Open VirtualFile | Closed ClosedVirtualFile
+-- | Read a virtual file from the current snapshot
+getOpenFile :: VirtualFileEntry -> Maybe VirtualFile
+getOpenFile (Open vf) = Just vf
+getOpenFile _         = Nothing
 -- | Read a virtual file from the current snapshot
 getVirtualFile :: NormalizedFilePath -> Action (Maybe VirtualFile)
 getVirtualFile nf = do
   vfs <- fmap _vfsMap . liftIO . readTVarIO . vfsVar =<< getShakeExtras
-  pure $! Map.lookup (filePathToUri' nf) vfs -- Don't leak a reference to the entire map
+  let file = getOpenFile =<< Map.lookup (filePathToUri' nf) vfs
+  pure $! file -- Don't leak a reference to the entire map
 
 -- Take a snapshot of the current LSP VFS
 vfsSnapshot :: Maybe (LSP.LanguageContextEnv a) -> IO VFS
@@ -452,7 +494,7 @@ getIdeOptionsIO ide = do
 -- | Return the most recent, potentially stale, value and a PositionMapping
 -- for the version of that value.
 lastValueIO :: IdeRule k v => ShakeExtras -> k -> NormalizedFilePath -> IO (Maybe (v, PositionMapping))
-lastValueIO s@ShakeExtras{positionMapping,persistentKeys,state} k file = do
+lastValueIO s@ShakeExtras{positionMapping,persistentKeys,stateValues} k file = do
 
     let readPersistent
           | IdeTesting testing <- ideTesting s -- Don't read stale persistent values in tests
@@ -466,7 +508,7 @@ lastValueIO s@ShakeExtras{positionMapping,persistentKeys,state} k file = do
             MaybeT $ pure $ (,del,ver) <$> fromDynamic dv
           case mv of
             Nothing -> atomicallyNamed "lastValueIO 1" $ do
-                STM.focus (Focus.alter (alterValue $ Failed True)) (toKey k file) state
+                STM.focus (Focus.alter (alterValue $ Failed True)) (toKey k file) stateValues
                 return Nothing
             Just (v,del,mbVer) -> do
                 actual_version <- case mbVer of
@@ -474,7 +516,7 @@ lastValueIO s@ShakeExtras{positionMapping,persistentKeys,state} k file = do
                   Nothing -> (Just . ModificationTime <$> getModTime (fromNormalizedFilePath file))
                               `catch` (\(_ :: IOException) -> pure Nothing)
                 atomicallyNamed "lastValueIO 2" $ do
-                  STM.focus (Focus.alter (alterValue $ Stale (Just del) actual_version (toDyn v))) (toKey k file) state
+                  STM.focus (Focus.alter (alterValue $ Stale (Just del) actual_version (toDyn v))) (toKey k file) stateValues
                   Just . (v,) . addOldDelta del <$> mappingForVersion positionMapping file actual_version
 
         -- We got a new stale value from the persistent rule, insert it in the map without affecting diagnostics
@@ -485,7 +527,7 @@ lastValueIO s@ShakeExtras{positionMapping,persistentKeys,state} k file = do
           -- Something already succeeded before, leave it alone
           _        -> old
 
-    atomicallyNamed "lastValueIO 4"  (STM.lookup (toKey k file) state) >>= \case
+    atomicallyNamed "lastValueIO 4"  (STM.lookup (toKey k file) stateValues) >>= \case
       Nothing -> readPersistent
       Just (ValueWithDiagnostics value _) -> case value of
         Succeeded ver (fromDynamic -> Just v) ->
@@ -599,8 +641,8 @@ deleteValue
   -> k
   -> NormalizedFilePath
   -> STM [Key]
-deleteValue ShakeExtras{state} key file = do
-    STM.delete (toKey key file) state
+deleteValue ShakeExtras{stateValues} key file = do
+    STM.delete (toKey key file) stateValues
     return [toKey key file]
 
 
@@ -659,7 +701,7 @@ shakeOpen :: Recorder (WithPriority Log)
 shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
   shakeProfileDir (IdeReportProgress reportProgress)
   ideTesting
-  withHieDb threadQueue opts monitoring rules rootDir = mdo
+  withHieDb threadQueue opts argMonitoring rules rootDir = mdo
     -- see Note [Serializing runs in separate thread]
     let indexQueue = tIndexQueue threadQueue
         restartQueue = tRestartQueue threadQueue
@@ -668,7 +710,7 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
     ideNc <- initNameCache 'r' knownKeyNames
     shakeExtras <- do
         globals <- newTVarIO HMap.empty
-        state <- STM.newIO
+        stateValues <- STM.newIO
         diagnostics <- STM.newIO
         hiddenDiagnostics <- STM.newIO
         publishedDiagnostics <- STM.newIO
@@ -681,18 +723,17 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
         indexCompleted <- newTVarIO 0
         semanticTokensId <- newTVarIO 0
         indexProgressReporting <- progressReportingNoTrace
-            (liftM2 (+) (length <$> readTVar indexPending) (readTVar indexCompleted))
-            (readTVar indexCompleted)
-            lspEnv "Indexing" optProgressStyle
+            (liftM2 (+) (length <$> readTVar indexPending) (readTVar indexCompleted) )
+            (readTVar indexCompleted) lspEnv "Indexing" optProgressStyle
         let hiedbWriter = HieDbWriter{..}
         exportsMap <- newTVarIO mempty
         -- lazily initialize the exports map with the contents of the hiedb
-        -- TODO: exceptions can be swallowed here?
-        _ <- async $ do
+        async <- async $ do
             logWith recorder Debug LogCreateHieDbExportsMapStart
             em <- createExportsMapHieDb withHieDb
             atomically $ modifyTVar' exportsMap (<> em)
             logWith recorder Debug $ LogCreateHieDbExportsMapFinish (ExportsMap.size em)
+        link async
 
         progress <-
             if reportProgress
@@ -707,6 +748,7 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
         pure ShakeExtras{shakeRecorder = recorder, ..}
     shakeDb  <-
         shakeNewDatabase
+            restartQueue
             opts { shakeExtra = newShakeExtra shakeExtras }
             rules
     shakeSession <- newEmptyMVar
@@ -719,6 +761,9 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
 
     checkParents <- optCheckParents
 
+
+    logMonitoring <- newLogMonitoring recorder
+    let monitoring = logMonitoring <> argMonitoring
     -- monitoring
     let readValuesCounter = fromIntegral . countRelevantKeys checkParents <$> getStateKeys shakeExtras
         readDirtyKeys = fromIntegral . countRelevantKeys checkParents . toListKeySet <$> readTVarIO(dirtyKeys shakeExtras)
@@ -726,6 +771,7 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
         readExportsMap = fromIntegral . ExportsMap.exportsMapSize <$> readTVarIO (exportsMap shakeExtras)
         readDatabaseCount = fromIntegral . countRelevantKeys checkParents . map fst <$> shakeGetDatabaseKeys shakeDb
         readDatabaseStep =  fromIntegral <$> shakeGetBuildStep shakeDb
+        readDatabaseActionQueueCount = fromIntegral <$> shakeGetActionQueueLength shakeDb
 
     registerGauge monitoring "ghcide.values_count" readValuesCounter
     registerGauge monitoring "ghcide.dirty_keys_count" readDirtyKeys
@@ -733,15 +779,31 @@ shakeOpen recorder lspEnv defaultConfig idePlugins debouncer
     registerGauge monitoring "ghcide.exports_map_count" readExportsMap
     registerGauge monitoring "ghcide.database_count" readDatabaseCount
     registerCounter monitoring "ghcide.num_builds" readDatabaseStep
+    registerCounter monitoring "ghcide.database_action_queue_count" readDatabaseActionQueueCount
 
     stopMonitoring <- start monitoring
 
     let ideState = IdeState{..}
     return ideState
-
+newLogMonitoring :: MonadIO m => Recorder (WithPriority Log) -> m Monitoring
+newLogMonitoring logger = do
+    actions <- newIORef []
+    let registerCounter name readA = do
+            let update = do
+                    val <- readA
+                    logWith logger Info $ LogMonitering name (fromIntegral val)
+            atomicModifyIORef'_ actions (update :)
+        registerGauge = registerCounter
+    let start = do
+            a <- regularly 10 $ sequence_ =<< readIORef actions
+            return (cancel a)
+    return Monitoring{..}
+    where
+        regularly :: Seconds -> IO () -> IO (Async ())
+        regularly delay act = async $ forever (act >> sleep delay)
 
 getStateKeys :: ShakeExtras -> IO [Key]
-getStateKeys = (fmap.fmap) fst . atomically . ListT.toList . STM.listT . state
+getStateKeys = (fmap.fmap) fst . atomically . ListT.toList . STM.listT . stateValues
 
 -- | Must be called in the 'Initialized' handler and only once
 shakeSessionInit :: Recorder (WithPriority Log) -> IdeState -> IO ()
@@ -793,21 +855,21 @@ 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 $ awaitRunInThread (restartQueue shakeExtras) $ do
+    void $ awaitRunInThreadAtHead (restartQueue shakeExtras) $ do
         withMVar'
             shakeSession
             (\runner -> do
                 (stopTime,()) <- duration $ logErrorAfter 10 $ cancelShakeSession runner
+                queue <- atomicallyNamed "actionQueue - peek" $ peekInProgress $ actionQueue shakeExtras
                 keys <- ioActionBetweenShakeSession
                 -- it is every important to update the dirty keys after we enter the critical section
                 -- see Note [Housekeeping rule cache and dirty key outside of hls-graph]
                 atomically $ modifyTVar' (dirtyKeys shakeExtras) $ \x -> foldl' (flip insertKeySet) x keys
                 res <- shakeDatabaseProfile shakeDb
                 backlog <- readTVarIO $ dirtyKeys shakeExtras
-                queue <- atomicallyNamed "actionQueue - peek" $ peekInProgress $ actionQueue shakeExtras
-
                 -- this log is required by tests
-                logWith recorder Debug $ LogBuildSessionRestart reason queue backlog stopTime res
+                step <- shakeGetBuildStep shakeDb
+                logWith recorder Debug $ LogBuildSessionRestart reason queue backlog stopTime res step
             )
             -- It is crucial to be masked here, otherwise we can get killed
             -- between spawning the new thread and updating shakeSession.
@@ -829,12 +891,13 @@ shakeEnqueue :: ShakeExtras -> DelayedAction a -> IO (IO a)
 shakeEnqueue ShakeExtras{actionQueue, shakeRecorder} act = do
     (b, dai) <- instantiateDelayedAction act
     atomicallyNamed "actionQueue - push" $ pushQueue dai actionQueue
+    logWith shakeRecorder Debug $ LogShakeText (T.pack $ "Enqueued action: " <> actionName act)
     let wait' barrier =
             waitBarrier barrier `catches`
               [ Handler(\BlockedIndefinitelyOnMVar ->
                     fail $ "internal bug: forever blocked on MVar for " <>
                             actionName act)
-              , Handler (\e@AsyncCancelled -> do
+              , Handler (\e@(SomeAsyncException _) -> do
                   logWith shakeRecorder Debug $ LogCancelledAction (T.pack $ actionName act)
 
                   atomicallyNamed "actionQueue - abort" $ abortQueue dai actionQueue
@@ -862,7 +925,9 @@ newSession recorder extras@ShakeExtras{..} vfsMod shakeDb acts reason = do
       VFSModified vfs -> atomically $ writeTVar vfsVar vfs
 
     IdeOptions{optRunSubset} <- getIdeOptionsIO extras
+
     reenqueued <- atomicallyNamed "actionQueue - peek" $ peekInProgress actionQueue
+    step <- getShakeStep shakeDb
     allPendingKeys <-
         if optRunSubset
           then Just <$> readTVarIO dirtyKeys
@@ -870,12 +935,20 @@ newSession recorder extras@ShakeExtras{..} vfsMod shakeDb acts reason = do
     let
         -- A daemon-like action used to inject additional work
         -- Runs actions from the work queue sequentially
-        pumpActionThread otSpan = do
-            d <- liftIO $ atomicallyNamed "action queue - pop" $ popQueue actionQueue
-            actionFork (run otSpan d) $ \_ -> pumpActionThread otSpan
+        logResult :: Show a => String -> [Either SomeException a] -> IO ()
+        logResult label results = for_ results $ \case
+            Left e | Just (AsyncParentKill _ _) <- fromException e  -> logWith recorder Debug $ LogShakeText (T.pack $ label ++ " failed: " ++ show e)
+            Left e  -> logWith recorder Error $ LogShakeText (T.pack $ label ++ " failed: " ++ show e)
+            Right r -> logWith recorder Debug $ LogShakeText (T.pack $ label ++ " finished: " ++ show r)
+        pumpActionThread = do
+            logWith recorder Debug $ LogShakeText (T.pack $ "Starting action" ++ "(step: " <> show step)
+            d <- runActionInDbCb actionName run (popQueue actionQueue) (logResult "pumpActionThread" . return)
+            step <- getShakeStep shakeDb
+            logWith recorder Debug $ LogShakeText (T.pack $ "started action" ++ "(step: " <> show step <> "): " <> actionName d)
+            pumpActionThread
 
         -- TODO figure out how to thread the otSpan into defineEarlyCutoff
-        run _otSpan d  = do
+        run d = do
             start <- liftIO offsetTime
             getAction d
             liftIO $ atomicallyNamed "actionQueue - done" $ doneQueue d actionQueue
@@ -883,34 +956,36 @@ newSession recorder extras@ShakeExtras{..} vfsMod shakeDb acts reason = do
             logWith recorder (actionPriority d) $ LogDelayedAction d runTime
 
         -- The inferred type signature doesn't work in ghc >= 9.0.1
-        workRun :: (forall b. IO b -> IO b) -> IO (IO ())
-        workRun restore = withSpan "Shake session" $ \otSpan -> do
+        -- workRun :: (forall b. IO b -> IO b) -> IO ()
+        workRun start restore = withSpan "Shake session" $ \otSpan -> do
           setTag otSpan "reason" (fromString reason)
           setTag otSpan "queue" (fromString $ unlines $ map actionName reenqueued)
           whenJust allPendingKeys $ \kk -> setTag otSpan "keys" (BS8.pack $ unlines $ map show $ toListKeySet kk)
-          let keysActs = pumpActionThread otSpan : map (run otSpan) (reenqueued ++ acts)
-          res <- try @SomeException $
-            restore $ shakeRunDatabaseForKeys (toListKeySet <$> allPendingKeys) shakeDb keysActs
-          return $ do
-              let exception =
-                    case res of
-                      Left e -> Just e
-                      _      -> Nothing
-              logWith recorder Debug $ LogBuildSessionFinish exception
+          res <- try @SomeException $ restore start
+          logWith recorder Debug $ LogBuildSessionFinish step res
 
-    -- Do the work in a background thread
-    workThread <- asyncWithUnmask workRun
 
-    -- run the wrap up in a separate thread since it contains interruptible
-    -- commands (and we are not using uninterruptible mask)
-    -- TODO: can possibly swallow exceptions?
-    _ <- async $ join $ wait workThread
+    let keysActs = pumpActionThread : map run (reenqueued ++ acts)
+    -- first we increase the step, so any actions started from here on
+    start <- shakeRunDatabaseForKeysSep (toListKeySet <$> allPendingKeys) shakeDb keysActs
+    -- Do the work in a background thread
+    parentTid <- myThreadId
+    workThread <- asyncWithUnmask $ \x -> do
+        childThreadId <- myThreadId
+        logWith recorder Info $ LogShakeText ("Starting shake thread: " <> T.pack (show childThreadId) <> " (parent: " <> T.pack (show parentTid) <> ")")
+        workRun start x
 
     --  Cancelling is required to flush the Shake database when either
     --  the filesystem or the Ghc configuration have changed
+
     let cancelShakeSession :: IO ()
-        cancelShakeSession = cancel workThread
+        cancelShakeSession = do
+            logWith recorder Info $ LogShakeText ("Starting shake cancellation: " <> " (" <> T.pack (show reason) <> ")")
+            tid <- myThreadId
+            cancelWith workThread $ AsyncParentKill tid step
+            shakeShutDatabase shakeDb
 
+    -- should wait until the step has increased
     pure (ShakeSession{..})
 
 instantiateDelayedAction
@@ -959,9 +1034,9 @@ garbageCollectDirtyKeysOlderThan maxAge checkParents = otTracedGarbageCollection
 garbageCollectKeys :: String -> Int -> CheckParents -> [(Key, Int)] -> Action [Key]
 garbageCollectKeys label maxAge checkParents agedKeys = do
     start <- liftIO offsetTime
-    ShakeExtras{state, dirtyKeys, lspEnv, shakeRecorder, ideTesting} <- getShakeExtras
+    ShakeExtras{stateValues, dirtyKeys, lspEnv, shakeRecorder, ideTesting} <- getShakeExtras
     (n::Int, garbage) <- liftIO $
-        foldM (removeDirtyKey dirtyKeys state) (0,[]) agedKeys
+        foldM (removeDirtyKey dirtyKeys stateValues) (0,[]) agedKeys
     t <- liftIO start
     when (n>0) $ liftIO $ do
         logWith shakeRecorder Debug $ LogShakeGarbageCollection (T.pack label) n t
@@ -1021,12 +1096,16 @@ defineNoDiagnostics recorder op = defineEarlyCutoff recorder $ RuleNoDiagnostics
 -- | Request a Rule result if available
 use :: IdeRule k v
     => k -> NormalizedFilePath -> Action (Maybe v)
-use key file = runIdentity <$> uses key (Identity file)
+use key file = do
+    [r] <- uses key [file]
+    return r
 
 -- | Request a Rule result, it not available return the last computed result, if any, which may be stale
 useWithStale :: IdeRule k v
     => k -> NormalizedFilePath -> Action (Maybe (v, PositionMapping))
-useWithStale key file = runIdentity <$> usesWithStale key (Identity file)
+useWithStale key file = do
+    [r] <-usesWithStale key [file]
+    return r
 
 -- |Request a Rule result, it not available return the last computed result
 --  which may be stale.
@@ -1037,7 +1116,9 @@ useWithStale key file = runIdentity <$> usesWithStale key (Identity file)
 -- WARNING: Not suitable for PluginHandlers. Use `useWithStaleE` instead.
 useWithStale_ :: IdeRule k v
     => k -> NormalizedFilePath -> Action (v, PositionMapping)
-useWithStale_ key file = runIdentity <$> usesWithStale_ key (Identity file)
+useWithStale_ key file = do
+    [r] <- usesWithStale_ key [file]
+    return r
 
 -- |Plural version of 'useWithStale_'
 --
@@ -1045,7 +1126,7 @@ useWithStale_ key file = runIdentity <$> usesWithStale_ key (Identity file)
 -- none available.
 --
 -- WARNING: Not suitable for PluginHandlers.
-usesWithStale_ :: (Traversable f, IdeRule k v) => k -> f NormalizedFilePath -> Action (f (v, PositionMapping))
+usesWithStale_ :: (IdeRule k v) => k -> [NormalizedFilePath] -> Action [(v, PositionMapping)]
 usesWithStale_ key files = do
     res <- usesWithStale key files
     case sequence res of
@@ -1090,8 +1171,8 @@ useWithStaleFast' key file = do
   -- keep updating the value in the key.
   waitValue <- delayedAction $ mkDelayedAction ("C:" ++ show key ++ ":" ++ fromNormalizedFilePath file) Debug $ use key file
 
-  s@ShakeExtras{state} <- askShake
-  r <- liftIO $ atomicallyNamed "useStateFast" $ getValues state key file
+  s@ShakeExtras{stateValues} <- askShake
+  r <- liftIO $ atomicallyNamed "useStateFast" $ getValues stateValues key file
   liftIO $ case r of
     -- block for the result if we haven't computed before
     Nothing -> do
@@ -1117,7 +1198,9 @@ useNoFile key = use key emptyFilePath
 --
 -- WARNING: Not suitable for PluginHandlers. Use `useE` instead.
 use_ :: IdeRule k v => k -> NormalizedFilePath -> Action v
-use_ key file = runIdentity <$> uses_ key (Identity file)
+use_ key file = do
+    [r] <- uses_ key [file]
+    return r
 
 useNoFile_ :: IdeRule k v => k -> Action v
 useNoFile_ key = use_ key emptyFilePath
@@ -1128,7 +1211,7 @@ useNoFile_ key = use_ key emptyFilePath
 -- none available.
 --
 -- WARNING: Not suitable for PluginHandlers. Use `usesE` instead.
-uses_ :: (Traversable f, IdeRule k v) => k -> f NormalizedFilePath -> Action (f v)
+uses_ :: (IdeRule k v) => k -> [NormalizedFilePath] -> Action [v]
 uses_ key files = do
     res <- uses key files
     case sequence res of
@@ -1136,13 +1219,13 @@ uses_ key files = do
         Just v  -> return v
 
 -- | Plural version of 'use'
-uses :: (Traversable f, IdeRule k v)
-    => k -> f NormalizedFilePath -> Action (f (Maybe v))
+uses :: (IdeRule k v)
+    => k -> [NormalizedFilePath] -> Action [(Maybe v)]
 uses key files = fmap (\(A value) -> currentValue value) <$> apply (fmap (Q . (key,)) files)
 
 -- | Return the last computed result which might be stale.
-usesWithStale :: (Traversable f, IdeRule k v)
-    => k -> f NormalizedFilePath -> Action (f (Maybe (v, PositionMapping)))
+usesWithStale :: (IdeRule k v)
+    => k -> [NormalizedFilePath] -> Action [(Maybe (v, PositionMapping))]
 usesWithStale key files = do
     _ <- apply (fmap (Q . (key,)) files)
     -- We don't look at the result of the 'apply' since 'lastValue' will
@@ -1169,8 +1252,10 @@ useWithSeparateFingerprintRule_ fingerKey key file = do
 
 useWithoutDependency :: IdeRule k v
     => k -> NormalizedFilePath -> Action (Maybe v)
-useWithoutDependency key file =
-    (\(Identity (A value)) -> currentValue value) <$> applyWithoutDependency (Identity (Q (key, file)))
+useWithoutDependency key file = do
+    [A x] <- applyWithoutDependency [Q (key, file)]
+    return $ currentValue x
+
 
 data RuleBody k v
   = Rule (k -> NormalizedFilePath -> Action (Maybe BS.ByteString, IdeResult v))
@@ -1235,13 +1320,13 @@ defineEarlyCutoff'
     -> (Value v -> Action (Maybe BS.ByteString, IdeResult v))
     -> Action (RunResult (A (RuleResult k)))
 defineEarlyCutoff' doDiagnostics cmp key file mbOld mode action = do
-    ShakeExtras{state, progress, dirtyKeys} <- getShakeExtras
+    ShakeExtras{stateValues, progress, dirtyKeys} <- getShakeExtras
     options <- getIdeOptions
     let trans g x =  withRunInIO $ \run -> g (run x)
     (if optSkipProgress options key then id else trans (inProgress progress file)) $ do
         val <- case mbOld of
             Just old | mode == RunDependenciesSame -> do
-                mbValue <- liftIO $ atomicallyNamed "define - read 1" $ getValues state key file
+                mbValue <- liftIO $ atomicallyNamed "define - read 1" $ getValues stateValues key file
                 case mbValue of
                     -- No changes in the dependencies and we have
                     -- an existing successful result.
@@ -1257,7 +1342,7 @@ defineEarlyCutoff' doDiagnostics cmp key file mbOld mode action = do
         res <- case val of
             Just res -> return res
             Nothing -> do
-                staleV <- liftIO $ atomicallyNamed "define -read 3" $ getValues state key file <&> \case
+                staleV <- liftIO $ atomicallyNamed "define -read 3" $ getValues stateValues key file <&> \case
                     Nothing                   -> Failed False
                     Just (Succeeded ver v, _) -> Stale Nothing ver v
                     Just (Stale d ver v, _)   -> Stale d ver v
@@ -1285,7 +1370,7 @@ defineEarlyCutoff' doDiagnostics cmp key file mbOld mode action = do
                     (A res) $ do
                         -- this hook needs to be run in the same transaction as the key is marked clean
                         -- see Note [Housekeeping rule cache and dirty key outside of hls-graph]
-                        setValues state key file res (Vector.fromList diags)
+                        setValues stateValues key file res (Vector.fromList diags)
                         modifyTVar' dirtyKeys (deleteKeySet $ toKey key file)
         return res
   where
@@ -1378,6 +1463,7 @@ updateFileDiagnostics recorder fp ver k ShakeExtras{diagnostics, hiddenDiagnosti
                         Just env -> LSP.runLspT env $ do
                             liftIO $ tag "count" (show $ Prelude.length newDiags)
                             liftIO $ tag "key" (show k)
+                            -- logWith recorder Debug $ LogDiagsPublishLog k lastPublish newDiags
                             LSP.sendNotification SMethod_TextDocumentPublishDiagnostics $
                                 LSP.PublishDiagnosticsParams (fromNormalizedUri uri') (fmap fromIntegral ver) (map fdLspDiagnostic newDiags)
                 return action
diff --git a/ghcide/src/Development/IDE/Core/WorkerThread.hs b/ghcide/src/Development/IDE/Core/WorkerThread.hs
deleted file mode 100644
index 6d141c7ef3..0000000000
--- a/ghcide/src/Development/IDE/Core/WorkerThread.hs
+++ /dev/null
@@ -1,59 +0,0 @@
-{-
-Module : Development.IDE.Core.WorkerThread
-Author : @soulomoon
-SPDX-License-Identifier: Apache-2.0
-
-Description : This module provides an API for managing worker threads in the IDE.
-see Note [Serializing runs in separate thread]
--}
-module Development.IDE.Core.WorkerThread
-    (withWorkerQueue, awaitRunInThread)
- where
-
-import           Control.Concurrent.Async  (AsyncCancelled (AsyncCancelled),
-                                            withAsync)
-import           Control.Concurrent.STM
-import           Control.Concurrent.Strict (newBarrier, signalBarrier,
-                                            waitBarrier)
-import           Control.Exception.Safe    (Exception (fromException),
-                                            SomeException, throwIO, try)
-import           Control.Monad             (forever)
-import           Control.Monad.Cont        (ContT (ContT))
-
-{-
-Note [Serializing runs in separate thread]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-We often want to take long-running actions using some resource that cannot be shared.
-In this instance it is useful to have a queue of jobs to run using the resource.
-Like the db writes, session loading in session loader, shake session restarts.
-
-Originally we used various ways to implement this, but it was hard to maintain and error prone.
-Moreover, we can not stop these threads uniformly when we are shutting down the server.
--}
-
--- | 'withWorkerQueue' creates a new 'TQueue', and launches a worker
--- thread which polls the queue for requests and runs the given worker
--- function on them.
-withWorkerQueue :: (t -> IO a) -> ContT () IO (TQueue t)
-withWorkerQueue workerAction = ContT $ \mainAction -> do
-    q <- newTQueueIO
-    withAsync (writerThread q) $ \_ -> mainAction q
-    where
-        writerThread q =
-            forever $ do
-                l <- atomically $ readTQueue q
-                workerAction l
-
--- | 'awaitRunInThread' queues up an 'IO' action to be run by a worker thread,
--- and then blocks until the result is computed. If the action throws an
--- non-async exception, it is rethrown in the calling thread.
-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
-    atomically $ writeTQueue q $ try act >>= signalBarrier barrier
-    resultOrException <- waitBarrier barrier
-    case resultOrException of
-        Left e  -> throwIO (e :: SomeException)
-        Right r -> return r
diff --git a/ghcide/src/Development/IDE/GHC/Compat/Error.hs b/ghcide/src/Development/IDE/GHC/Compat/Error.hs
index de59afa146..63ec75bfc9 100644
--- a/ghcide/src/Development/IDE/GHC/Compat/Error.hs
+++ b/ghcide/src/Development/IDE/GHC/Compat/Error.hs
@@ -18,6 +18,9 @@ module Development.IDE.GHC.Compat.Error (
   DriverMessage (..),
   -- * General Diagnostics
   Diagnostic(..),
+  -- * GHC Hints
+  GhcHint (SuggestExtension),
+  LanguageExtensionHint (..),
   -- * Prisms and lenses for error selection
   _TcRnMessage,
   _TcRnMessageWithCtx,
diff --git a/ghcide/src/Development/IDE/GHC/Compat/Outputable.hs b/ghcide/src/Development/IDE/GHC/Compat/Outputable.hs
index ccec23c9c3..8414a7c8c3 100644
--- a/ghcide/src/Development/IDE/GHC/Compat/Outputable.hs
+++ b/ghcide/src/Development/IDE/GHC/Compat/Outputable.hs
@@ -9,6 +9,7 @@ module Development.IDE.GHC.Compat.Outputable (
     ppr, pprPanic, text, vcat, (<+>), ($$), empty, hang, nest, punctuate,
     printSDocQualifiedUnsafe,
     printWithoutUniques,
+    printWithoutUniquesOneLine,
     mkPrintUnqualifiedDefault,
     PrintUnqualified,
     defaultUserStyle,
@@ -27,6 +28,7 @@ module Development.IDE.GHC.Compat.Outputable (
     pprMsgEnvelopeBagWithLoc,
     Error.getMessages,
     renderWithContext,
+    showSDocOneLine,
     defaultSDocContext,
     errMsgDiagnostic,
     unDecorated,
@@ -76,8 +78,14 @@ type PrintUnqualified = NamePprCtx
 --
 -- It print with a user-friendly style like: `a_a4ME` as `a`.
 printWithoutUniques :: Outputable a => a -> String
-printWithoutUniques =
-  renderWithContext (defaultSDocContext
+printWithoutUniques = printWithoutUniques' renderWithContext
+
+printWithoutUniquesOneLine :: Outputable a => a -> String
+printWithoutUniquesOneLine = printWithoutUniques' showSDocOneLine
+
+printWithoutUniques' :: Outputable a => (SDocContext -> SDoc -> String) -> a -> String
+printWithoutUniques' showSDoc =
+  showSDoc (defaultSDocContext
     {
       sdocStyle = defaultUserStyle
     , sdocSuppressUniques = True
diff --git a/ghcide/src/Development/IDE/GHC/Util.hs b/ghcide/src/Development/IDE/GHC/Util.hs
index fb051bda5a..9f1303c7cf 100644
--- a/ghcide/src/Development/IDE/GHC/Util.hs
+++ b/ghcide/src/Development/IDE/GHC/Util.hs
@@ -27,6 +27,7 @@ module Development.IDE.GHC.Util(
     dontWriteHieFiles,
     disableWarningsAsErrors,
     printOutputable,
+    printOutputableOneLine,
     getExtensions,
     stripOccNamePrefix,
     ) where
@@ -264,11 +265,17 @@ ioe_dupHandlesNotCompatible h =
 --   1. print with a user-friendly style: `a_a4ME` as `a`.
 --   2. unescape escape sequences of printable unicode characters within a pair of double quotes
 printOutputable :: Outputable a => a -> T.Text
-printOutputable =
+printOutputable = printOutputable' printWithoutUniques
+
+printOutputableOneLine :: Outputable a => a -> T.Text
+printOutputableOneLine = printOutputable' printWithoutUniquesOneLine
+
+printOutputable' :: Outputable a => (a -> String) -> a -> T.Text
+printOutputable' print =
     -- IfaceTyLit from GHC.Iface.Type implements Outputable with 'show'.
     -- Showing a String escapes non-ascii printable characters. We unescape it here.
     -- More discussion at https://github.com/haskell/haskell-language-server/issues/3115.
-    unescape . T.pack . printWithoutUniques
+    unescape . T.pack . print
 {-# INLINE printOutputable #-}
 
 getExtensions :: ParsedModule -> [Extension]
diff --git a/ghcide/src/Development/IDE/LSP/LanguageServer.hs b/ghcide/src/Development/IDE/LSP/LanguageServer.hs
index 918e024a4f..9a56f02137 100644
--- a/ghcide/src/Development/IDE/LSP/LanguageServer.hs
+++ b/ghcide/src/Development/IDE/LSP/LanguageServer.hs
@@ -12,6 +12,8 @@ module Development.IDE.LSP.LanguageServer
     , ThreadQueue
     , runWithWorkerThreads
     , Setup (..)
+    , InitializationContext (..)
+    , untilMVar'
     ) where
 
 import           Control.Concurrent.STM
@@ -35,32 +37,56 @@ import           UnliftIO.Directory
 import           UnliftIO.Exception
 
 import qualified Colog.Core                            as Colog
+import           Control.Concurrent.Extra              (newBarrier,
+                                                        signalBarrier,
+                                                        waitBarrier)
 import           Control.Monad.IO.Unlift               (MonadUnliftIO)
 import           Control.Monad.Trans.Cont              (evalContT)
 import           Development.IDE.Core.IdeConfiguration
+import           Development.IDE.Core.Service          (shutdown)
 import           Development.IDE.Core.Shake            hiding (Log)
 import           Development.IDE.Core.Tracing
-import           Development.IDE.Core.WorkerThread     (withWorkerQueue)
 import qualified Development.IDE.Session               as Session
 import           Development.IDE.Types.Shake           (WithHieDb,
                                                         WithHieDbShield (..))
+import           Development.IDE.WorkerThread
 import           Ide.Logger
 import           Language.LSP.Server                   (LanguageContextEnv,
                                                         LspServerLog,
                                                         type (<~>))
+import           System.Time.Extra                     (Seconds)
+import           System.Timeout                        (timeout)
 data Log
   = LogRegisteringIdeConfig !IdeConfiguration
   | LogReactorThreadException !SomeException
   | LogReactorMessageActionException !SomeException
-  | LogReactorThreadStopped
+  | LogReactorThreadStopped Int
   | LogCancelledRequest !SomeLspId
   | LogSession Session.Log
   | LogLspServer LspServerLog
-  | LogServerShutdownMessage
+  | LogReactorShutdownRequested Bool
+  | LogShutDownTimeout Int
+  | LogServerExitWith (Either () Int)
+  | LogReactorShutdownConfirmed !T.Text
+  | LogInitializeIdeStateTookTooLong Seconds
   deriving Show
 
 instance Pretty Log where
   pretty = \case
+    LogInitializeIdeStateTookTooLong seconds ->
+        "Building the initial session took more than" <+> pretty seconds <+> "seconds"
+    LogReactorShutdownRequested b ->
+      "Requested reactor shutdown; stop signal posted: " <+> pretty b
+    LogReactorShutdownConfirmed msg ->
+        "Reactor shutdown confirmed: " <+> pretty msg
+    LogServerExitWith (Right 0) ->
+      "Server exited successfully"
+    LogServerExitWith (Right code) ->
+      "Server exited with failure code" <+> pretty code
+    LogServerExitWith (Left _) ->
+      "Server forcefully exited due to exception in reactor thread"
+    LogShutDownTimeout seconds ->
+        "Shutdown timeout, the server will exit now after waiting for" <+> pretty seconds  <+> "seconds"
     LogRegisteringIdeConfig ideConfig ->
       -- This log is also used to identify if HLS starts successfully in vscode-haskell,
       -- don't forget to update the corresponding test in vscode-haskell if the text in
@@ -74,13 +100,38 @@ instance Pretty Log where
       vcat
         [ "ReactorMessageActionException"
         , pretty $ displayException e ]
-    LogReactorThreadStopped ->
-      "Reactor thread stopped"
+    LogReactorThreadStopped i ->
+      "Reactor thread stopped" <+> pretty i
     LogCancelledRequest requestId ->
       "Cancelled request" <+> viaShow requestId
     LogSession msg -> pretty msg
     LogLspServer msg -> pretty msg
-    LogServerShutdownMessage -> "Received shutdown message"
+
+-- | Context for initializing the LSP language server.
+-- This record encapsulates all the configuration and callback functions
+-- needed to set up and run the language server initialization process.
+data InitializationContext config = InitializationContext
+  { ctxRecorder :: Recorder (WithPriority Log)
+    -- ^ Logger for recording server events and diagnostics
+  , ctxDefaultRoot :: FilePath
+    -- ^ Default root directory for the workspace, see Note [Root Directory]
+  , ctxGetHieDbLoc :: FilePath -> IO FilePath
+    -- ^ Function to determine the HIE database location for a given root path
+  , ctxGetIdeState :: LSP.LanguageContextEnv config -> FilePath -> WithHieDb -> ThreadQueue -> IO IdeState
+    -- ^ Function to create and initialize the IDE state with the given environment
+  , ctxUntilReactorStopSignal :: IO () -> IO ()
+    -- ^ Lifetime control: MVar to signal reactor shutdown
+  , ctxconfirmReactorShutdown :: T.Text -> IO ()
+    -- ^ Callback to log/confirm reactor shutdown with a reason
+  , ctxForceShutdown :: IO ()
+    -- ^ Action to forcefully exit the server when exception occurs
+  , ctxClearReqId :: SomeLspId -> IO ()
+    -- ^ Function to clear/cancel a request by its ID
+  , ctxWaitForCancel :: SomeLspId -> IO ()
+    -- ^ Function to wait for a request cancellation by its ID
+  , ctxClientMsgChan :: Chan ReactorMessage
+    -- ^ Channel for communicating with the reactor message loop
+  }
 
 data Setup config m a
   = MkSetup
@@ -136,8 +187,8 @@ runLanguageServer recorder options inH outH defaultConfig parseConfig onConfigCh
             outH
             serverDefinition
 
-    untilMVar clientMsgVar $
-        runServer `finally` sequence_ onExit
+    untilMVar' clientMsgVar runServer `finally` sequence_ onExit
+        >>= logWith recorder Info . LogServerExitWith
 
 setupLSP ::
      forall config.
@@ -155,8 +206,21 @@ setupLSP recorder defaultRoot getHieDbLoc userHandlers getIdeState clientMsgVar
 
   -- An MVar to control the lifetime of the reactor loop.
   -- The loop will be stopped and resources freed when it's full
-  reactorLifetime <- newEmptyMVar
-  let stopReactorLoop = void $ tryPutMVar reactorLifetime ()
+  reactorStopSignal <- newEmptyMVar
+  reactorConfirmBarrier <- newBarrier
+  let
+    untilReactorStopSignal = untilMVar reactorStopSignal
+    confirmReactorShutdown reason = do
+      logWith recorder Debug $ LogReactorShutdownConfirmed reason
+      signalBarrier reactorConfirmBarrier ()
+    requestReactorShutdown = do
+      k <- tryPutMVar reactorStopSignal ()
+      logWith recorder Info $ LogReactorShutdownRequested k
+      let timeOutSeconds = 3
+      timeout (timeOutSeconds * 1_000_000) (waitBarrier reactorConfirmBarrier) >>= \case
+        Just () -> pure ()
+        -- If we don't get confirmation within 2 seconds, we log a warning and shutdown anyway.
+        Nothing -> logWith recorder Warning $ LogShutDownTimeout timeOutSeconds
 
   -- Forcefully exit
   let exit = void $ tryPutMVar clientMsgVar ()
@@ -185,49 +249,64 @@ setupLSP recorder defaultRoot getHieDbLoc userHandlers getIdeState clientMsgVar
   let staticHandlers = mconcat
         [ userHandlers
         , cancelHandler cancelRequest
-        , exitHandler exit
-        , shutdownHandler recorder stopReactorLoop
+        , shutdownHandler recorder requestReactorShutdown
+        , exitHandler recorder exit
         ]
         -- Cancel requests are special since they need to be handled
         -- out of order to be useful. Existing handlers are run afterwards.
 
-  let doInitialize = handleInit recorder defaultRoot getHieDbLoc getIdeState reactorLifetime exit clearReqId waitForCancel clientMsgChan
+  let initParams = InitializationContext
+        { ctxRecorder = recorder
+        , ctxDefaultRoot = defaultRoot
+        , ctxGetHieDbLoc = getHieDbLoc
+        , ctxGetIdeState = getIdeState
+        , ctxUntilReactorStopSignal = untilReactorStopSignal
+        , ctxconfirmReactorShutdown = confirmReactorShutdown
+        , ctxForceShutdown = exit
+        , ctxClearReqId = clearReqId
+        , ctxWaitForCancel = waitForCancel
+        , ctxClientMsgChan = clientMsgChan
+        }
+
+  let doInitialize = handleInit initParams
 
   let interpretHandler (env,  st) = LSP.Iso (LSP.runLspT env . flip (runReaderT . unServerM) (clientMsgChan,st)) liftIO
-
-  let onExit = [stopReactorLoop, exit]
+  let onExit = [void $ tryPutMVar reactorStopSignal ()]
 
   pure MkSetup {doInitialize, staticHandlers, interpretHandler, onExit}
 
 
 handleInit
-    :: Recorder (WithPriority Log)
-    -> FilePath -- ^ root directory, see Note [Root Directory]
-    -> (FilePath -> IO FilePath)
-    -> (LSP.LanguageContextEnv config -> FilePath -> WithHieDb -> ThreadQueue -> IO IdeState)
-    -> MVar ()
-    -> IO ()
-    -> (SomeLspId -> IO ())
-    -> (SomeLspId -> IO ())
-    -> Chan ReactorMessage
+    :: InitializationContext config
     -> LSP.LanguageContextEnv config -> TRequestMessage Method_Initialize -> IO (Either err (LSP.LanguageContextEnv config, IdeState))
-handleInit recorder defaultRoot getHieDbLoc getIdeState lifetime exitClientMsg clearReqId waitForCancel clientMsgChan env (TRequestMessage _ _ m params) = otTracedHandler "Initialize" (show m) $ \sp -> do
+handleInit initParams env (TRequestMessage _ _ m params) = otTracedHandler "Initialize" (show m) $ \sp -> do
     traceWithSpan sp params
-    -- only shift if lsp root is different from the rootDir
-    -- see Note [Root Directory]
+  -- only shift if lsp root is different from the rootDir
+  -- see Note [Root Directory]
+    let
+      recorder = ctxRecorder initParams
+      defaultRoot = ctxDefaultRoot initParams
+      untilReactorStopSignal = ctxUntilReactorStopSignal initParams
+      lifetimeConfirm = ctxconfirmReactorShutdown initParams
     root <- case LSP.resRootPath env of
-        Just lspRoot | lspRoot /= defaultRoot -> setCurrentDirectory lspRoot >> return lspRoot
-        _ -> pure defaultRoot
-    dbLoc <- getHieDbLoc root
+      Just lspRoot | lspRoot /= defaultRoot -> setCurrentDirectory lspRoot >> return lspRoot
+      _ -> pure defaultRoot
+    dbLoc <- ctxGetHieDbLoc initParams root
     let initConfig = parseConfiguration params
     logWith recorder Info $ LogRegisteringIdeConfig initConfig
-    dbMVar <- newEmptyMVar
-
-
-    let handleServerException (Left e) = do
-            logWith recorder Error $ LogReactorThreadException e
-            exitClientMsg
-        handleServerException (Right _) = pure ()
+    ideMVar <- newEmptyMVar
+
+    let handleServerExceptionOrShutDown me = do
+            -- shutdown shake
+            tryReadMVar ideMVar >>= mapM_ shutdown
+            case me of
+                Left e -> do
+                    lifetimeConfirm "due to exception in reactor thread"
+                    logWith recorder Error $ LogReactorThreadException e
+                    ctxForceShutdown initParams
+                _ -> do
+                    lifetimeConfirm "due to shutdown message"
+                    return ()
 
         exceptionInHandler e = do
             logWith recorder Error $ LogReactorMessageActionException e
@@ -235,13 +314,13 @@ handleInit recorder defaultRoot getHieDbLoc getIdeState lifetime exitClientMsg c
         checkCancelled :: forall m . LspId m -> IO () -> (TResponseError m -> IO ()) -> IO ()
         checkCancelled _id act k =
             let sid = SomeLspId _id
-            in flip finally (clearReqId sid) $
+            in flip finally (ctxClearReqId initParams sid) $
                 catch (do
                     -- We could optimize this by first checking if the id
                     -- is in the cancelled set. However, this is unlikely to be a
                     -- bottleneck and the additional check might hide
                     -- issues with async exceptions that need to be fixed.
-                    cancelOrRes <- race (waitForCancel sid) act
+                    cancelOrRes <- race (ctxWaitForCancel initParams sid) act
                     case cancelOrRes of
                         Left () -> do
                             logWith recorder Debug $ LogCancelledRequest sid
@@ -250,20 +329,22 @@ handleInit recorder defaultRoot getHieDbLoc getIdeState lifetime exitClientMsg c
                 ) $ \(e :: SomeException) -> do
                     exceptionInHandler e
                     k $ TResponseError (InR ErrorCodes_InternalError) (T.pack $ show e) Nothing
-    _ <- flip forkFinally handleServerException $ do
-        untilMVar lifetime $ runWithWorkerThreads (cmapWithPrio LogSession recorder) dbLoc $ \withHieDb' threadQueue' -> do
-            putMVar dbMVar (WithHieDbShield withHieDb',threadQueue')
-            forever $ do
-                msg <- readChan clientMsgChan
-                -- We dispatch notifications synchronously and requests asynchronously
-                -- This is to ensure that all file edits and config changes are applied before a request is handled
-                case msg of
-                    ReactorNotification act -> handle exceptionInHandler act
-                    ReactorRequest _id act k -> void $ async $ checkCancelled _id act k
-        logWith recorder Info LogReactorThreadStopped
-
-    (WithHieDbShield withHieDb, threadQueue) <- takeMVar dbMVar
-    ide <- getIdeState env root withHieDb threadQueue
+    _ <- flip forkFinally handleServerExceptionOrShutDown $ do
+            runWithWorkerThreads (cmapWithPrio LogSession recorder) dbLoc $ \withHieDb' threadQueue' ->
+                do
+                ide <- ctxGetIdeState initParams env root withHieDb' threadQueue'
+                putMVar ideMVar ide
+                -- We might be blocked indefinitly at initialization if reactorStop is signaled
+                -- before we putMVar.
+                untilReactorStopSignal $ forever $ do
+                    msg <- readChan $ ctxClientMsgChan initParams
+                    -- We dispatch notifications synchronously and requests asynchronously
+                    -- This is to ensure that all file edits and config changes are applied before a request is handled
+                    case msg of
+                        ReactorNotification act -> handle exceptionInHandler act
+                        ReactorRequest _id act k -> void $ async $ checkCancelled _id act k
+
+    ide <- readMVar ideMVar
     registerIdeConfiguration (shakeExtras ide) initConfig
     pure $ Right (env,ide)
 
@@ -273,9 +354,9 @@ handleInit recorder defaultRoot getHieDbLoc getIdeState lifetime exitClientMsg c
 -- see Note [Serializing runs in separate thread]
 runWithWorkerThreads :: Recorder (WithPriority Session.Log) -> FilePath -> (WithHieDb -> ThreadQueue -> IO ()) -> IO ()
 runWithWorkerThreads recorder dbLoc f = evalContT $ do
-            sessionRestartTQueue <- withWorkerQueue id
-            sessionLoaderTQueue <- withWorkerQueue id
             (WithHieDbShield hiedb, threadQueue) <- runWithDb recorder dbLoc
+            sessionRestartTQueue <- withWorkerQueueSimple (logWith (cmapWithPrio Session.LogSessionWorkerThread recorder) Debug) "RestartTQueue"
+            sessionLoaderTQueue <- withWorkerQueueSimple (logWith (cmapWithPrio Session.LogSessionWorkerThread recorder) Debug) "SessionLoaderTQueue"
             liftIO $ f hiedb (ThreadQueue threadQueue sessionRestartTQueue sessionLoaderTQueue)
 
 -- | Runs the action until it ends or until the given MVar is put.
@@ -286,6 +367,9 @@ runWithWorkerThreads recorder dbLoc f = evalContT $ do
 untilMVar :: MonadUnliftIO m => MVar () -> m a -> m ()
 untilMVar mvar io = race_ (readMVar mvar) io
 
+untilMVar' :: MonadUnliftIO m => MVar a -> m b -> m (Either a b)
+untilMVar' mvar io = race (readMVar mvar) io
+
 cancelHandler :: (SomeLspId -> IO ()) -> LSP.Handlers (ServerM c)
 cancelHandler cancelRequest = LSP.notificationHandler SMethod_CancelRequest $ \TNotificationMessage{_params=CancelParams{_id}} ->
   liftIO $ cancelRequest (SomeLspId (toLspId _id))
@@ -294,17 +378,15 @@ cancelHandler cancelRequest = LSP.notificationHandler SMethod_CancelRequest $ \T
         toLspId (InR y) = IdString y
 
 shutdownHandler :: Recorder (WithPriority Log) -> IO () -> LSP.Handlers (ServerM c)
-shutdownHandler recorder stopReactor = LSP.requestHandler SMethod_Shutdown $ \_ resp -> do
-    (_, ide) <- ask
-    liftIO $ logWith recorder Debug LogServerShutdownMessage
-    -- stop the reactor to free up the hiedb connection
-    liftIO stopReactor
-    -- flush out the Shake session to record a Shake profile if applicable
-    liftIO $ shakeShut ide
+shutdownHandler _recorder requestReactorShutdown = LSP.requestHandler SMethod_Shutdown $ \_ resp -> do
+    -- stop the reactor to free up the hiedb connection and shut down shake
+    liftIO requestReactorShutdown
     resp $ Right Null
 
-exitHandler :: IO () -> LSP.Handlers (ServerM c)
-exitHandler exit = LSP.notificationHandler SMethod_Exit $ const $ liftIO exit
+exitHandler :: Recorder (WithPriority Log) -> IO () -> LSP.Handlers (ServerM c)
+exitHandler _recorder exit = LSP.notificationHandler SMethod_Exit $ \_ -> do
+    -- stop the reactor to free up the hiedb connection and shut down shake
+    liftIO exit
 
 modifyOptions :: LSP.Options -> LSP.Options
 modifyOptions x = x{ LSP.optTextDocumentSync   = Just $ tweakTDS origTDS
diff --git a/ghcide/src/Development/IDE/Plugin/Completions.hs b/ghcide/src/Development/IDE/Plugin/Completions.hs
index d92bf1da85..7278b8a3e1 100644
--- a/ghcide/src/Development/IDE/Plugin/Completions.hs
+++ b/ghcide/src/Development/IDE/Plugin/Completions.hs
@@ -132,11 +132,11 @@ resolveCompletion ide _pid comp@CompletionItem{_detail,_documentation,_data_} ur
     name <- liftIO $ lookupNameCache nc mod occ
     mdkm <- liftIO $ runIdeAction "CompletionResolve.GetDocMap" (shakeExtras ide) $ useWithStaleFast GetDocMap file
     let (dm,km) = case mdkm of
-          Just (DKMap docMap tyThingMap, _) -> (docMap,tyThingMap)
-          Nothing                           -> (mempty, mempty)
+          Just (DKMap docMap tyThingMap _argDocMap, _) -> (docMap,tyThingMap)
+          Nothing                                      -> (mempty, mempty)
     doc <- case lookupNameEnv dm name of
       Just doc -> pure $ spanDocToMarkdown doc
-      Nothing -> liftIO $ spanDocToMarkdown <$> getDocumentationTryGhc (hscEnv sess) name
+      Nothing -> liftIO $ spanDocToMarkdown . fst <$> getDocumentationTryGhc (hscEnv sess) name
     typ <- case lookupNameEnv km name of
       _ | not needType -> pure Nothing
       Just ty -> pure (safeTyThingType ty)
diff --git a/ghcide/src/Development/IDE/Plugin/Completions/Logic.hs b/ghcide/src/Development/IDE/Plugin/Completions/Logic.hs
index 0a5cecaca8..6c59a5ffe5 100644
--- a/ghcide/src/Development/IDE/Plugin/Completions/Logic.hs
+++ b/ghcide/src/Development/IDE/Plugin/Completions/Logic.hs
@@ -857,7 +857,7 @@ mergeListsBy cmp all_lists = merge_lists all_lists
 
 -- |From the given cursor position, gets the prefix module or record for autocompletion
 getCompletionPrefix :: Position -> VFS.VirtualFile -> PosPrefixInfo
-getCompletionPrefix pos (VFS.VirtualFile _ _ ropetext) = getCompletionPrefixFromRope pos ropetext
+getCompletionPrefix pos (VFS.VirtualFile _ _ ropetext _) = getCompletionPrefixFromRope pos ropetext
 
 getCompletionPrefixFromRope :: Position -> Rope.Rope -> PosPrefixInfo
 getCompletionPrefixFromRope pos@(Position l c) ropetext =
diff --git a/ghcide/src/Development/IDE/Plugin/Test.hs b/ghcide/src/Development/IDE/Plugin/Test.hs
index e24bcfeee9..8c0733b22f 100644
--- a/ghcide/src/Development/IDE/Plugin/Test.hs
+++ b/ghcide/src/Development/IDE/Plugin/Test.hs
@@ -39,7 +39,7 @@ import           Development.IDE.Graph.Database       (ShakeDatabase,
                                                        shakeGetBuildStep,
                                                        shakeGetCleanKeys)
 import           Development.IDE.Graph.Internal.Types (Result (resultBuilt, resultChanged, resultVisited),
-                                                       Step (Step))
+                                                       Step (..))
 import qualified Development.IDE.Graph.Internal.Types as Graph
 import           Development.IDE.Types.Action
 import           Development.IDE.Types.HscEnvEq       (HscEnvEq (hscEnv))
@@ -53,7 +53,6 @@ import qualified "list-t" ListT
 import qualified StmContainers.Map                    as STM
 import           System.Time.Extra
 
-type Age = Int
 data TestRequest
     = BlockSeconds Seconds           -- ^ :: Null
     | GetInterfaceFilesDir Uri       -- ^ :: String
@@ -64,7 +63,6 @@ data TestRequest
     | GetBuildKeysBuilt          -- ^ :: [(String]
     | GetBuildKeysChanged        -- ^ :: [(String]
     | GetBuildEdgesCount         -- ^ :: Int
-    | GarbageCollectDirtyKeys CheckParents Age    -- ^ :: [String] (list of keys collected)
     | GetStoredKeys                  -- ^ :: [String] (list of keys in store)
     | GetFilesOfInterest             -- ^ :: [FilePath]
     | GetRebuildsCount               -- ^ :: Int (number of times we recompiled with GHC)
@@ -126,11 +124,8 @@ testRequestHandler s GetBuildKeysVisited = liftIO $ do
 testRequestHandler s GetBuildEdgesCount = liftIO $ do
     count <- shakeGetBuildEdges $ shakeDb s
     return $ Right $ toJSON count
-testRequestHandler s (GarbageCollectDirtyKeys parents age) = do
-    res <- liftIO $ runAction "garbage collect dirty" s $ garbageCollectDirtyKeysOlderThan age parents
-    return $ Right $ toJSON $ map show res
 testRequestHandler s GetStoredKeys = do
-    keys <- liftIO $ atomically $ map fst <$> ListT.toList (STM.listT $ state $ shakeExtras s)
+    keys <- liftIO $ atomically $ map fst <$> ListT.toList (STM.listT $ stateValues $ shakeExtras s)
     return $ Right $ toJSON $ map show keys
 testRequestHandler s GetFilesOfInterest = do
     ff <- liftIO $ getFilesOfInterest s
diff --git a/ghcide/src/Development/IDE/Spans/AtPoint.hs b/ghcide/src/Development/IDE/Spans/AtPoint.hs
index 50df0f5ba5..ded1781f7f 100644
--- a/ghcide/src/Development/IDE/Spans/AtPoint.hs
+++ b/ghcide/src/Development/IDE/Spans/AtPoint.hs
@@ -256,7 +256,7 @@ atPoint
   -> HscEnv
   -> Position
   -> IO (Maybe (Maybe Range, [T.Text]))
-atPoint IdeOptions{} (HAR _ (hf :: HieASTs a) rf _ (kind :: HieKind hietype)) (DKMap dm km) env pos =
+atPoint IdeOptions{} (HAR _ (hf :: HieASTs a) rf _ (kind :: HieKind hietype)) (DKMap dm km _am) env pos =
     listToMaybe <$> sequence (pointCommand hf pos hoverInfo)
   where
     -- Hover info for values/data
diff --git a/ghcide/src/Development/IDE/Spans/Common.hs b/ghcide/src/Development/IDE/Spans/Common.hs
index 996e55ef1a..90d77b71fb 100644
--- a/ghcide/src/Development/IDE/Spans/Common.hs
+++ b/ghcide/src/Development/IDE/Spans/Common.hs
@@ -13,6 +13,7 @@ module Development.IDE.Spans.Common (
 , spanDocToMarkdownForTest
 , DocMap
 , TyThingMap
+, ArgDocMap
 , srcSpanToMdLink
 ) where
 
@@ -29,6 +30,7 @@ import           GHC.Generics
 import           System.FilePath
 
 import           Control.Lens
+import           Data.IntMap                  (IntMap)
 import           Development.IDE.GHC.Compat
 import           Development.IDE.GHC.Orphans  ()
 import qualified Language.LSP.Protocol.Lens   as JL
@@ -36,6 +38,7 @@ import           Language.LSP.Protocol.Types
 
 type DocMap = NameEnv SpanDoc
 type TyThingMap = NameEnv TyThing
+type ArgDocMap = NameEnv (IntMap SpanDoc)
 
 -- | Shows IEWrappedName, without any modifier, qualifier or unique identifier.
 unqualIEWrapName :: IEWrappedName GhcPs -> T.Text
diff --git a/ghcide/src/Development/IDE/Spans/Documentation.hs b/ghcide/src/Development/IDE/Spans/Documentation.hs
index dcf7778de3..a4b6242315 100644
--- a/ghcide/src/Development/IDE/Spans/Documentation.hs
+++ b/ghcide/src/Development/IDE/Spans/Documentation.hs
@@ -16,6 +16,7 @@ import           Control.Monad.Extra             (findM)
 import           Control.Monad.IO.Class
 import           Data.Either
 import           Data.Foldable
+import           Data.IntMap                     (IntMap)
 import           Data.List.Extra
 import qualified Data.Map                        as M
 import           Data.Maybe
@@ -42,21 +43,27 @@ mkDocMap
   -> IO DocAndTyThingMap
 mkDocMap env rm this_mod =
   do
-     (Just Docs{docs_decls = UniqMap this_docs}) <- extractDocs (hsc_dflags env) this_mod
+     (Just Docs{docs_decls = UniqMap this_docs, docs_args = UniqMap this_arg_docs}) <- extractDocs (hsc_dflags env) this_mod
      d <- foldrM getDocs (fmap (\(_, x) -> (map hsDocString x) `SpanDocString` SpanDocUris Nothing Nothing) this_docs) names
      k <- foldrM getType (tcg_type_env this_mod) names
-     pure $ DKMap d k
+     a <- foldrM getArgDocs (fmap (\(_, m) -> fmap (\x -> [hsDocString x] `SpanDocString` SpanDocUris Nothing Nothing) m) this_arg_docs) names
+     pure $ DKMap d k a
   where
     getDocs n nameMap
       | maybe True (mod ==) $ nameModule_maybe n = pure nameMap -- we already have the docs in this_docs, or they do not exist
       | otherwise = do
-      doc <- getDocumentationTryGhc env n
+      (doc, _argDoc) <- getDocumentationTryGhc env n
       pure $ extendNameEnv nameMap n doc
     getType n nameMap
       | Nothing <- lookupNameEnv nameMap n
       = do kind <- lookupKind env n
            pure $ maybe nameMap (extendNameEnv nameMap n) kind
       | otherwise = pure nameMap
+    getArgDocs n nameMap
+      | maybe True (mod ==) $ nameModule_maybe n = pure nameMap
+      | otherwise = do
+      (_doc, argDoc) <- getDocumentationTryGhc env n
+      pure $ extendNameEnv nameMap n argDoc
     names = rights $ S.toList idents
     idents = M.keysSet rm
     mod = tcg_mod this_mod
@@ -65,23 +72,23 @@ lookupKind :: HscEnv -> Name -> IO (Maybe TyThing)
 lookupKind env =
     fmap (fromRight Nothing) . catchSrcErrors (hsc_dflags env) "span" . lookupName env
 
-getDocumentationTryGhc :: HscEnv -> Name -> IO SpanDoc
+getDocumentationTryGhc :: HscEnv -> Name -> IO (SpanDoc, IntMap SpanDoc)
 getDocumentationTryGhc env n =
-  (fromMaybe emptySpanDoc . listToMaybe <$> getDocumentationsTryGhc env [n])
-    `catch` (\(_ :: IOEnvFailure) -> pure emptySpanDoc)
+  (fromMaybe (emptySpanDoc, mempty) . listToMaybe <$> getDocumentationsTryGhc env [n])
+    `catch` (\(_ :: IOEnvFailure) -> pure (emptySpanDoc, mempty))
 
-getDocumentationsTryGhc :: HscEnv -> [Name] -> IO [SpanDoc]
+getDocumentationsTryGhc :: HscEnv -> [Name] -> IO [(SpanDoc, IntMap SpanDoc)]
 getDocumentationsTryGhc env names = do
   resOr <- catchSrcErrors (hsc_dflags env) "docs" $ getDocsBatch env names
   case resOr of
       Left _    -> return []
       Right res -> zipWithM unwrap res names
   where
-    unwrap (Right (Just docs, _)) n = SpanDocString (map hsDocString docs) <$> getUris n
+    unwrap (Right (Just docs, argDocs)) n = (\uris -> (SpanDocString (map hsDocString docs) uris, fmap (\x -> SpanDocString [hsDocString x] uris) argDocs)) <$> getUris n
     unwrap _ n                      = mkSpanDocText n
 
     mkSpanDocText name =
-      SpanDocText [] <$> getUris name
+      (\uris -> (SpanDocText [] uris, mempty)) <$> getUris name
 
     -- Get the uris to the documentation and source html pages if they exist
     getUris name = do
diff --git a/ghcide/src/Development/IDE/Types/Action.hs b/ghcide/src/Development/IDE/Types/Action.hs
index 0aedd1d0da..225f5b603d 100644
--- a/ghcide/src/Development/IDE/Types/Action.hs
+++ b/ghcide/src/Development/IDE/Types/Action.hs
@@ -7,7 +7,9 @@ module Development.IDE.Types.Action
     popQueue,
     doneQueue,
     peekInProgress,
-  abortQueue,countQueue)
+    abortQueue,
+    countQueue,
+    isActionQueueEmpty)
 where
 
 import           Control.Concurrent.STM
@@ -86,3 +88,9 @@ countQueue ActionQueue{..} = do
 
 peekInProgress :: ActionQueue -> STM [DelayedActionInternal]
 peekInProgress ActionQueue {..} = Set.toList <$> readTVar inProgress
+
+isActionQueueEmpty :: ActionQueue -> STM Bool
+isActionQueueEmpty ActionQueue {..} = do
+    emptyQueue <- isEmptyTQueue newActions
+    inProg <- Set.null <$> readTVar inProgress
+    return (emptyQueue && inProg)
diff --git a/ghcide/src/Development/IDE/Types/HscEnvEq.hs b/ghcide/src/Development/IDE/Types/HscEnvEq.hs
index 1c2ed1732f..e14ab56847 100644
--- a/ghcide/src/Development/IDE/Types/HscEnvEq.hs
+++ b/ghcide/src/Development/IDE/Types/HscEnvEq.hs
@@ -15,7 +15,6 @@ import           Control.Exception               (evaluate, mask, throwIO)
 import           Control.Monad.Extra             (eitherM, join, mapMaybeM)
 import           Data.Either                     (fromRight)
 import           Data.IORef
-import qualified Data.Map                        as M
 import           Data.Unique                     (Unique)
 import qualified Data.Unique                     as Unique
 import           Development.IDE.GHC.Compat      hiding (newUnique)
@@ -25,9 +24,7 @@ import           Development.IDE.GHC.Util        (lookupPackageConfig)
 import           Development.IDE.Graph.Classes
 import           Development.IDE.Types.Exports   (ExportsMap, createExportsMap)
 import           GHC.Driver.Env                  (hsc_all_home_unit_ids)
-import           Ide.PluginUtils                 (toAbsolute)
 import           OpenTelemetry.Eventlog          (withSpan)
-import           System.Directory                (makeAbsolute)
 
 
 -- | An 'HscEnv' with equality. Two values are considered equal
@@ -54,7 +51,6 @@ newHscEnvEq :: HscEnv -> IO HscEnvEq
 newHscEnvEq hscEnv' = do
 
     mod_cache <- newIORef emptyInstalledModuleEnv
-    file_cache <- newIORef M.empty
     -- This finder cache is for things which are outside of things which are tracked
     -- by HLS. For example, non-home modules, dependent object files etc
 #if MIN_VERSION_ghc(9,11,0)
diff --git a/haskell-language-server.cabal b/haskell-language-server.cabal
index 91adbcbe37..c30eebb8af 100644
--- a/haskell-language-server.cabal
+++ b/haskell-language-server.cabal
@@ -839,6 +839,59 @@ test-suite hls-stan-plugin-tests
   default-extensions:
     OverloadedStrings
 
+-----------------------------
+-- signature help plugin
+-----------------------------
+
+flag signatureHelp
+  description: Enable signature help plugin
+  default:     True
+  manual:      True
+
+common signatureHelp
+  if flag(signatureHelp)
+    build-depends: haskell-language-server:hls-signature-help-plugin
+    cpp-options: -Dhls_signatureHelp
+
+library hls-signature-help-plugin
+  import:           defaults, pedantic, warnings
+  if !flag(signatureHelp)
+    buildable: False
+  exposed-modules:  Ide.Plugin.SignatureHelp
+  hs-source-dirs:   plugins/hls-signature-help-plugin/src
+  default-extensions:
+    DerivingStrategies
+    LambdaCase
+    OverloadedStrings
+  build-depends:
+    , containers
+    , ghc
+    , ghcide                == 2.11.0.0
+    , hls-plugin-api        == 2.11.0.0
+    , lsp-types
+    , text
+    , transformers
+
+
+test-suite hls-signature-help-plugin-tests
+  import:           defaults, pedantic, test-defaults, warnings
+  if !flag(signatureHelp)
+    buildable: False
+  type:             exitcode-stdio-1.0
+  hs-source-dirs:   plugins/hls-signature-help-plugin/test
+  main-is:          Main.hs
+  build-depends:
+    , ghcide
+    , haskell-language-server:hls-signature-help-plugin
+    , hls-test-utils             == 2.11.0.0
+    , lens
+    , lsp-types
+    , string-interpolate
+    , text
+  default-extensions:
+    DerivingStrategies
+    OverloadedStrings
+
 -----------------------------
 -- module name plugin
 -----------------------------
@@ -1858,6 +1911,7 @@ library
                   , retrie
                   , hlint
                   , stan
+                  , signatureHelp
                   , moduleName
                   , pragmas
                   , splice
diff --git a/hls-graph/hls-graph.cabal b/hls-graph/hls-graph.cabal
index 5eccb4d75e..b1553580d3 100644
--- a/hls-graph/hls-graph.cabal
+++ b/hls-graph/hls-graph.cabal
@@ -65,11 +65,14 @@ library
     Development.IDE.Graph.KeyMap
     Development.IDE.Graph.KeySet
     Development.IDE.Graph.Rule
+    Development.IDE.WorkerThread
     Paths_hls_graph
 
   autogen-modules:    Paths_hls_graph
   hs-source-dirs:     src
   build-depends:
+    , mtl ^>=2.3.1
+    , safe-exceptions ^>=0.1.7.4
     , aeson
     , async                 >=2.0
     , base                  >=4.12    && <5
@@ -92,6 +95,7 @@ library
     , transformers
     , unliftio
     , unordered-containers
+    , prettyprinter
 
   if flag(embed-files)
     cpp-options:   -DFILE_EMBED
@@ -129,6 +133,7 @@ test-suite tests
     -threaded -rtsopts -with-rtsopts=-N -fno-ignore-asserts
 
   build-depends:
+    , transformers
     , base
     , extra
     , hls-graph
diff --git a/hls-graph/src/Development/IDE/Graph.hs b/hls-graph/src/Development/IDE/Graph.hs
index 81ad3b3dfd..bb973c6130 100644
--- a/hls-graph/src/Development/IDE/Graph.hs
+++ b/hls-graph/src/Development/IDE/Graph.hs
@@ -5,7 +5,7 @@ module Development.IDE.Graph(
     Action, action,
     pattern Key,
     newKey, renderKey,
-    actionFinally, actionBracket, actionCatch, actionFork,
+    actionFinally, actionBracket, actionCatch,
     -- * Configuration
     ShakeOptions(shakeAllowRedefineRules, shakeExtra),
     getShakeExtra, getShakeExtraRules, newShakeExtra,
@@ -18,6 +18,7 @@ module Development.IDE.Graph(
     -- * Actions for inspecting the keys in the database
     getDirtySet,
     getKeysAndVisitedAge,
+
     module Development.IDE.Graph.KeyMap,
     module Development.IDE.Graph.KeySet,
     ) where
diff --git a/hls-graph/src/Development/IDE/Graph/Database.hs b/hls-graph/src/Development/IDE/Graph/Database.hs
index bd8601cd16..0b072974cb 100644
--- a/hls-graph/src/Development/IDE/Graph/Database.hs
+++ b/hls-graph/src/Development/IDE/Graph/Database.hs
@@ -4,13 +4,19 @@ module Development.IDE.Graph.Database(
     shakeNewDatabase,
     shakeRunDatabase,
     shakeRunDatabaseForKeys,
+    shakeRunDatabaseForKeysSep,
     shakeProfileDatabase,
     shakeGetBuildStep,
     shakeGetDatabaseKeys,
     shakeGetDirtySet,
     shakeGetCleanKeys
-    ,shakeGetBuildEdges) where
-import           Control.Concurrent.STM.Stats            (readTVarIO)
+    ,shakeGetBuildEdges,
+    shakeShutDatabase,
+    shakeGetActionQueueLength) where
+import           Control.Concurrent.STM.Stats            (atomically,
+                                                          readTVarIO)
+import           Control.Exception                       (SomeException)
+import           Control.Monad                           (join)
 import           Data.Dynamic
 import           Data.Maybe
 import           Development.IDE.Graph.Classes           ()
@@ -21,20 +27,24 @@ import           Development.IDE.Graph.Internal.Options
 import           Development.IDE.Graph.Internal.Profile  (writeProfile)
 import           Development.IDE.Graph.Internal.Rules
 import           Development.IDE.Graph.Internal.Types
+import           Development.IDE.WorkerThread            (TaskQueue)
 
 
 -- Placeholder to be the 'extra' if the user doesn't set it
 data NonExportedType = NonExportedType
 
-shakeNewDatabase :: ShakeOptions -> Rules () -> IO ShakeDatabase
-shakeNewDatabase opts rules = do
+shakeShutDatabase :: ShakeDatabase -> IO ()
+shakeShutDatabase (ShakeDatabase _ _ db) = shutDatabase db
+
+shakeNewDatabase :: TaskQueue (IO ()) -> ShakeOptions -> Rules () -> IO ShakeDatabase
+shakeNewDatabase que opts rules = do
     let extra = fromMaybe (toDyn NonExportedType) $ shakeExtra opts
     (theRules, actions) <- runRules extra rules
-    db <- newDatabase extra theRules
+    db <- newDatabase que extra theRules
     pure $ ShakeDatabase (length actions) actions db
 
-shakeRunDatabase :: ShakeDatabase -> [Action a] -> IO [a]
-shakeRunDatabase = shakeRunDatabaseForKeys Nothing
+shakeRunDatabase :: ShakeDatabase -> [Action a] -> IO [Either SomeException a]
+shakeRunDatabase s xs = shakeRunDatabaseForKeys Nothing s xs
 
 -- | Returns the set of dirty keys annotated with their age (in # of builds)
 shakeGetDirtySet :: ShakeDatabase -> IO [(Key, Int)]
@@ -52,15 +62,27 @@ unvoid :: Functor m => m () -> m a
 unvoid = fmap undefined
 
 -- | Assumes that the database is not running a build
-shakeRunDatabaseForKeys
+-- The nested IO is to
+-- seperate incrementing the step from running the build
+shakeRunDatabaseForKeysSep
     :: Maybe [Key]
       -- ^ Set of keys changed since last run. 'Nothing' means everything has changed
     -> ShakeDatabase
     -> [Action a]
-    -> IO [a]
-shakeRunDatabaseForKeys keysChanged (ShakeDatabase lenAs1 as1 db) as2 = do
+    -> IO (IO [Either SomeException a])
+shakeRunDatabaseForKeysSep keysChanged (ShakeDatabase lenAs1 as1 db) as2 = do
     incDatabase db keysChanged
-    fmap (drop lenAs1) $ runActions db $ map unvoid as1 ++ as2
+    return $ drop lenAs1 <$> runActions db (map unvoid as1 ++ as2)
+
+shakeRunDatabaseForKeys
+    :: Maybe [Key]
+      -- ^ Set of keys changed since last run. 'Nothing' means everything has changed
+    -> ShakeDatabase
+    -> [Action a]
+    -> (IO [Either SomeException a])
+shakeRunDatabaseForKeys keysChanged sdb as2 = join $ shakeRunDatabaseForKeysSep keysChanged sdb as2
+
+
 
 -- | Given a 'ShakeDatabase', write an HTML profile to the given file about the latest run.
 shakeProfileDatabase :: ShakeDatabase -> FilePath -> IO ()
@@ -83,3 +105,7 @@ shakeGetBuildEdges (ShakeDatabase _ _ db) = do
 --   annotated with how long ago (in # builds) they were visited
 shakeGetDatabaseKeys :: ShakeDatabase -> IO [(Key, Int)]
 shakeGetDatabaseKeys (ShakeDatabase _ _ db) = getKeysAndVisitAge db
+
+shakeGetActionQueueLength :: ShakeDatabase -> IO Int
+shakeGetActionQueueLength (ShakeDatabase _ _ db) =
+    atomically $ databaseGetActionQueueLength db
diff --git a/hls-graph/src/Development/IDE/Graph/Internal/Action.hs b/hls-graph/src/Development/IDE/Graph/Internal/Action.hs
index 6d47d9b511..abab30c930 100644
--- a/hls-graph/src/Development/IDE/Graph/Internal/Action.hs
+++ b/hls-graph/src/Development/IDE/Graph/Internal/Action.hs
@@ -2,7 +2,6 @@
 
 module Development.IDE.Graph.Internal.Action
 ( ShakeValue
-, actionFork
 , actionBracket
 , actionCatch
 , actionFinally
@@ -14,9 +13,11 @@ module Development.IDE.Graph.Internal.Action
 , runActions
 , Development.IDE.Graph.Internal.Action.getDirtySet
 , getKeysAndVisitedAge
+, runActionInDbCb
 ) where
 
 import           Control.Concurrent.Async
+import           Control.Concurrent.STM.Stats            (atomicallyNamed)
 import           Control.DeepSeq                         (force)
 import           Control.Exception
 import           Control.Monad.IO.Class
@@ -31,6 +32,9 @@ import           Development.IDE.Graph.Internal.Key
 import           Development.IDE.Graph.Internal.Rules    (RuleResult)
 import           Development.IDE.Graph.Internal.Types
 import           System.Exit
+import           UnliftIO                                (STM, atomically,
+                                                          newEmptyTMVarIO,
+                                                          putTMVar, readTMVar)
 
 type ShakeValue a = (Show a, Typeable a, Eq a, Hashable a, NFData a)
 
@@ -40,49 +44,51 @@ alwaysRerun = do
     ref <- Action $ asks actionDeps
     liftIO $ modifyIORef' ref (AlwaysRerunDeps mempty <>)
 
-parallel :: [Action a] -> Action [a]
-parallel [] = pure []
-parallel [x] = fmap (:[]) x
+parallel :: [Action a] -> Action [Either SomeException a]
+parallel [] = return []
 parallel xs = do
     a <- Action ask
     deps <- liftIO $ readIORef $ actionDeps a
     case deps of
         UnknownDeps ->
             -- if we are already in the rerun mode, nothing we do is going to impact our state
-            liftIO $ mapConcurrently (ignoreState a) xs
-        deps -> do
-            (newDeps, res) <- liftIO $ unzip <$> mapConcurrently (usingState a) xs
-            liftIO $ writeIORef (actionDeps a) $ mconcat $ deps : newDeps
-            pure res
-    where
-        usingState a x = do
-            ref <- newIORef mempty
-            res <- runReaderT (fromAction x) a{actionDeps=ref}
-            deps <- readIORef ref
-            pure (deps, res)
+            runActionInDb "parallel" xs
+        deps -> error $ "parallel not supported when we have precise dependencies: " ++ show deps
+            -- (newDeps, res) <- liftIO $ unzip <$> runActionInDb usingState xs
+            -- liftIO $ writeIORef (actionDeps a) $ mconcat $ deps : newDeps
+            -- return ()
+
+-- non-blocking version of runActionInDb
+runActionInDbCb :: (a -> String) -> (a -> Action result) -> STM a -> (Either SomeException result -> IO ()) -> Action a
+runActionInDbCb getTitle work getAct handler = do
+    a <- Action ask
+    liftIO $ atomicallyNamed "action queue - pop" $ do
+        act <- getAct
+        runInDataBase (getTitle act) (actionDatabase a) [(ignoreState a $ work act, handler)]
+        return act
+
+runActionInDb :: String -> [Action a] -> Action [Either SomeException a]
+runActionInDb title acts = do
+    a <- Action ask
+    xs <- mapM (\x -> do
+        barrier <- newEmptyTMVarIO
+        return (x, barrier)) acts
+    liftIO $ atomically $ runInDataBase title (actionDatabase a)
+        (map (\(x, b) -> (ignoreState a x, atomically . putTMVar b)) xs)
+    results <- liftIO $ mapM (atomically . readTMVar) $ fmap snd xs
+    return results
 
 ignoreState :: SAction -> Action b -> IO b
 ignoreState a x = do
     ref <- newIORef mempty
     runReaderT (fromAction x) a{actionDeps=ref}
 
-actionFork :: Action a -> (Async a -> Action b) -> Action b
-actionFork act k = do
-    a <- Action ask
-    deps <- liftIO $ readIORef $ actionDeps a
-    let db = actionDatabase a
-    case deps of
-        UnknownDeps -> do
-            -- if we are already in the rerun mode, nothing we do is going to impact our state
-            [res] <- liftIO $ withAsync (ignoreState a act) $ \as -> runActions db [k as]
-            return res
-        _ ->
-            error "please help me"
-
 isAsyncException :: SomeException -> Bool
 isAsyncException e
+    | Just (_ :: SomeAsyncException) <- fromException e = True
     | Just (_ :: AsyncCancelled) <- fromException e = True
     | Just (_ :: AsyncException) <- fromException e = True
+    | Just (_ :: AsyncParentKill) <- fromException e = True
     | Just (_ :: ExitCode) <- fromException e = True
     | otherwise = False
 
@@ -108,9 +114,12 @@ actionFinally a b = do
     Action $ lift $ finally (runReaderT (fromAction a) v) b
 
 apply1 :: (RuleResult key ~ value, ShakeValue key, Typeable value) => key -> Action value
-apply1 k = runIdentity <$> apply (Identity k)
+apply1 k = do
+    [r] <- apply [k]
+    return r
+
 
-apply :: (Traversable f, RuleResult key ~ value, ShakeValue key, Typeable value) => f key -> Action (f value)
+apply :: (RuleResult key ~ value, ShakeValue key, Typeable value) => [key] -> Action [value]
 apply ks = do
     db <- Action $ asks actionDatabase
     stack <- Action $ asks actionStack
@@ -121,14 +130,14 @@ apply ks = do
     pure vs
 
 -- | Evaluate a list of keys without recording any dependencies.
-applyWithoutDependency :: (Traversable f, RuleResult key ~ value, ShakeValue key, Typeable value) => f key -> Action (f value)
+applyWithoutDependency :: (RuleResult key ~ value, ShakeValue key, Typeable value) => [key] -> Action [value]
 applyWithoutDependency ks = do
     db <- Action $ asks actionDatabase
     stack <- Action $ asks actionStack
     (_, vs) <- liftIO $ build db stack ks
     pure vs
 
-runActions :: Database -> [Action a] -> IO [a]
+runActions :: Database -> [Action a] -> IO [Either SomeException a]
 runActions db xs = do
     deps <- newIORef mempty
     runReaderT (fromAction $ parallel xs) $ SAction db deps emptyStack
diff --git a/hls-graph/src/Development/IDE/Graph/Internal/Database.hs b/hls-graph/src/Development/IDE/Graph/Internal/Database.hs
index 359e5ceb6a..315d1615c9 100644
--- a/hls-graph/src/Development/IDE/Graph/Internal/Database.hs
+++ b/hls-graph/src/Development/IDE/Graph/Internal/Database.hs
@@ -8,16 +8,15 @@
 {-# LANGUAGE RecordWildCards    #-}
 {-# LANGUAGE TypeFamilies       #-}
 
-module Development.IDE.Graph.Internal.Database (compute, newDatabase, incDatabase, build, getDirtySet, getKeysAndVisitAge) where
+module Development.IDE.Graph.Internal.Database (compute, newDatabase, incDatabase, build, getDirtySet, getKeysAndVisitAge, AsyncParentKill(..)) where
 
 import           Prelude                              hiding (unzip)
 
-import           Control.Concurrent.Async
-import           Control.Concurrent.Extra
 import           Control.Concurrent.STM.Stats         (STM, atomically,
                                                        atomicallyNamed,
                                                        modifyTVar', newTVarIO,
-                                                       readTVarIO)
+                                                       readTVar, readTVarIO,
+                                                       retry)
 import           Control.Exception
 import           Control.Monad
 import           Control.Monad.IO.Class               (MonadIO (liftIO))
@@ -25,13 +24,12 @@ import           Control.Monad.Trans.Class            (lift)
 import           Control.Monad.Trans.Reader
 import qualified Control.Monad.Trans.State.Strict     as State
 import           Data.Dynamic
-import           Data.Either
 import           Data.Foldable                        (for_, traverse_)
 import           Data.IORef.Extra
 import           Data.Maybe
 import           Data.Traversable                     (for)
 import           Data.Tuple.Extra
-import           Debug.Trace                          (traceM)
+import           Debug.Trace                          (traceEvent)
 import           Development.IDE.Graph.Classes
 import           Development.IDE.Graph.Internal.Key
 import           Development.IDE.Graph.Internal.Rules
@@ -39,19 +37,20 @@ import           Development.IDE.Graph.Internal.Types
 import qualified Focus
 import qualified ListT
 import qualified StmContainers.Map                    as SMap
-import           System.IO.Unsafe
-import           System.Time.Extra                    (duration, sleep)
+import           System.Time.Extra                    (duration)
 
 #if MIN_VERSION_base(4,19,0)
 import           Data.Functor                         (unzip)
 #else
 import           Data.List.NonEmpty                   (unzip)
 #endif
+import           Development.IDE.WorkerThread         (TaskQueue)
 
 
-newDatabase :: Dynamic -> TheRules -> IO Database
-newDatabase databaseExtra databaseRules = do
+newDatabase :: TaskQueue (IO ()) -> Dynamic -> TheRules -> IO Database
+newDatabase databaseQueue databaseExtra databaseRules = do
     databaseStep <- newTVarIO $ Step 0
+    databaseThreads <- newTVarIO []
     databaseValues <- atomically SMap.new
     pure Database{..}
 
@@ -67,78 +66,87 @@ incDatabase db (Just kk) = do
         -- since we assume that no build is mutating the db.
         -- Therefore run one transaction per key to minimise contention.
         atomicallyNamed "incDatabase" $ SMap.focus updateDirty k (databaseValues db)
-
 -- all keys are dirty
 incDatabase db Nothing = do
     atomically $ modifyTVar'  (databaseStep db) $ \(Step i) -> Step $ i + 1
     let list = SMap.listT (databaseValues db)
+    -- all running keys are also dirty
     atomicallyNamed "incDatabase - all " $ flip ListT.traverse_ list $ \(k,_) ->
         SMap.focus updateDirty k (databaseValues db)
 
 updateDirty :: Monad m => Focus.Focus KeyDetails m ()
 updateDirty = Focus.adjust $ \(KeyDetails status rdeps) ->
             let status'
-                  | Running _ _ _ x <- status = Dirty x
+                  | Running _ x <- status = Dirty x
                   | Clean x <- status = Dirty (Just x)
                   | otherwise = status
             in KeyDetails status' rdeps
 -- | Unwrap and build a list of keys in parallel
 build
-    :: forall f key value . (Traversable f, RuleResult key ~ value, Typeable key, Show key, Hashable key, Eq key, Typeable value)
-    => Database -> Stack -> f key -> IO (f Key, f value)
+    :: forall key value . (RuleResult key ~ value, Typeable key, Show key, Hashable key, Eq key, Typeable value)
+    => Database -> Stack -> [key] -> IO ([Key], [value])
 -- build _ st k | traceShow ("build", st, k) False = undefined
 build db stack keys = do
-    built <- runAIO $ do
-        built <- builder db stack (fmap newKey keys)
-        case built of
-          Left clean  -> return clean
-          Right dirty -> liftIO dirty
-    let (ids, vs) = unzip built
-    pure (ids, fmap (asV . resultValue) vs)
+    step <- readTVarIO $ databaseStep db
+    go `catch` \e@(AsyncParentKill i s) -> do
+        if s == step
+            then throw e
+            else throw $ AsyncParentKill i $ Step (-1)
     where
-        asV :: Value -> value
-        asV (Value x) = unwrapDynamic x
+    go = do
+        -- step <- readTVarIO $ databaseStep db
+        -- built <- mapConcurrently (builderOne db stack) (fmap newKey keys)
+        built <- builder db stack (fmap newKey keys)
+        let (ids, vs) = unzip built
+        pure (ids, fmap (asV . resultValue) vs)
+        where
+            asV :: Value -> value
+            asV (Value x) = unwrapDynamic x
+
 
 -- | Build a list of keys and return their results.
 --  If none of the keys are dirty, we can return the results immediately.
 --  Otherwise, a blocking computation is returned *which must be evaluated asynchronously* to avoid deadlock.
-builder
-    :: Traversable f => Database -> Stack -> f Key -> AIO (Either (f (Key, Result)) (IO (f (Key, Result))))
+builder :: Database -> Stack -> [Key] -> IO [(Key, Result)]
 -- builder _ st kk | traceShow ("builder", st,kk) False = undefined
-builder db@Database{..} stack keys = withRunInIO $ \(RunInIO run) -> do
-    -- Things that I need to force before my results are ready
-    toForce <- liftIO $ newTVarIO []
-    current <- liftIO $ readTVarIO databaseStep
-    results <- liftIO $ for keys $ \id ->
-        -- Updating the status of all the dependencies atomically is not necessary.
-        -- Therefore, run one transaction per dep. to avoid contention
-        atomicallyNamed "builder" $ do
-            -- Spawn the id if needed
-            status <- SMap.lookup id databaseValues
-            val <- case viewDirty current $ maybe (Dirty Nothing) keyStatus status of
-                Clean r -> pure r
-                Running _ force val _
-                  | memberStack id stack -> throw $ StackException stack
-                  | otherwise -> do
-                    modifyTVar' toForce (Wait force :)
-                    pure val
-                Dirty s -> do
-                    let act = run (refresh db stack id s)
-                        (force, val) = splitIO (join act)
-                    SMap.focus (updateStatus $ Running current force val s) id databaseValues
-                    modifyTVar' toForce (Spawn force:)
-                    pure val
-
-            pure (id, val)
-
-    toForceList <- liftIO $ readTVarIO toForce
-    let waitAll = run $ waitConcurrently_ toForceList
-    case toForceList of
-        [] -> return $ Left results
-        _ -> return $ Right $ do
-                waitAll
-                pure results
-
+builder db stack [k]  = return <$> builderOne IsSingleton db stack k
+builder db stack keys = for keys $ \k -> builderOne NotSingleton db stack k
+data IsSingletonTask = IsSingleton | NotSingleton
+data BuildContinue = BCContinue | BCStop Result | BCRead (IO Result)
+
+builderOne :: IsSingletonTask -> Database -> Stack -> Key -> IO (Key, Result)
+builderOne isSingletonTask db@Database {..} stack id = mask $ \restore -> do
+  traceEvent ("builderOne: " ++ show id) return ()
+  res <- liftIO $ atomicallyNamed "builder" $ do
+    -- Spawn the id if needed
+    status <- SMap.lookup id databaseValues
+    current <- readTVar databaseStep
+
+    case viewDirty current $ maybe (Dirty Nothing) keyStatus status of
+      Dirty s -> do
+        SMap.focus (updateStatus $ Running current s) id databaseValues
+        case isSingletonTask of
+          IsSingleton ->
+            return $
+              BCRead $
+                restore (refresh db stack id s) `catch` \e@(SomeException _) -> do
+                  atomically $ SMap.focus (updateStatus $ Exception current e s) id databaseValues
+                  throw e
+          NotSingleton -> do
+            traceEvent ("Starting build of key: " ++ show id ++ ", step " ++ show current) $
+              runOneInDataBase (show id) db (refresh db stack id s) $
+                \e -> atomically $ SMap.focus (updateStatus $ Exception current e s) id databaseValues
+            return BCContinue
+      Clean r -> return $ BCStop r
+      -- force here might contains async exceptions from previous runs
+      Running _step _s
+        | memberStack id stack -> throw $ StackException stack
+        | otherwise -> retry
+      Exception _ e _s -> throw e
+  case res of
+    BCStop r   -> return (id, r)
+    BCContinue -> restore $ builderOne isSingletonTask db stack id
+    BCRead ioR -> (id,) <$> ioR
 
 -- | isDirty
 -- only dirty when it's build time is older than the changed time of one of its dependencies
@@ -152,44 +160,37 @@ isDirty me = any (\(_,dep) -> resultBuilt me < resultChanged dep)
 -- * If no dirty dependencies and we have evaluated the key previously, then we refresh it in the current thread.
 --   This assumes that the implementation will be a lookup
 -- * Otherwise, we spawn a new thread to refresh the dirty deps (if any) and the key itself
-refreshDeps :: KeySet -> Database -> Stack -> Key -> Result -> [KeySet] -> AIO Result
+refreshDeps :: KeySet -> Database -> Stack -> Key -> Result -> [KeySet] -> IO Result
 refreshDeps visited db stack key result = \case
     -- no more deps to refresh
-    [] -> liftIO $ compute db stack key RunDependenciesSame (Just result)
+    [] -> compute db stack key RunDependenciesSame (Just result)
     (dep:deps) -> do
         let newVisited = dep <> visited
         res <- builder db stack (toListKeySet (dep `differenceKeySet` visited))
-        case res of
-            Left res ->  if isDirty result res
+        if isDirty result res
                 -- restart the computation if any of the deps are dirty
-                then liftIO $ compute db stack key RunDependenciesChanged (Just result)
+                then compute db stack key RunDependenciesChanged (Just result)
                 -- else kick the rest of the deps
                 else refreshDeps newVisited db stack key result deps
-            Right iores -> do
-                res <- liftIO iores
-                if isDirty result res
-                    then liftIO $ compute db stack key RunDependenciesChanged (Just result)
-                    else refreshDeps newVisited db stack key result deps
 
--- | Refresh a key:
-refresh :: Database -> Stack -> Key -> Maybe Result -> AIO (IO Result)
+
+-- refresh :: Database -> Stack -> Key -> Maybe Result -> IO Result
 -- refresh _ st k _ | traceShow ("refresh", st, k) False = undefined
+refresh :: Database -> Stack -> Key -> Maybe Result -> IO Result
 refresh db stack key result = case (addStack key stack, result) of
     (Left e, _) -> throw e
-    (Right stack, Just me@Result{resultDeps = ResultDeps deps}) -> asyncWithCleanUp $ refreshDeps mempty db stack key me (reverse deps)
-    (Right stack, _) ->
-        asyncWithCleanUp $ liftIO $ compute db stack key RunDependenciesChanged result
-
+    (Right stack, Just me@Result{resultDeps = ResultDeps deps}) -> refreshDeps mempty db stack key me (reverse deps)
+    (Right stack, _) -> compute db stack key RunDependenciesChanged result
 -- | Compute a key.
 compute :: Database -> Stack -> Key -> RunMode -> Maybe Result -> IO Result
 -- compute _ st k _ _ | traceShow ("compute", st, k) False = undefined
 compute db@Database{..} stack key mode result = do
     let act = runRule databaseRules key (fmap resultData result) mode
-    deps <- newIORef UnknownDeps
+    deps <- liftIO $ newIORef UnknownDeps
     (execution, RunResult{..}) <-
-        duration $ runReaderT (fromAction act) $ SAction db deps stack
-    curStep <- readTVarIO databaseStep
-    deps <- readIORef deps
+        liftIO $ duration $ runReaderT (fromAction act) $ SAction db deps stack
+    curStep <- liftIO $ readTVarIO databaseStep
+    deps <- liftIO $ readIORef deps
     let lastChanged = maybe curStep resultChanged result
     let lastBuild = maybe curStep resultBuilt result
     -- changed time is always older than or equal to build time
@@ -212,12 +213,12 @@ compute db@Database{..} stack key mode result = do
             -- If an async exception strikes before the deps have been recorded,
             -- we won't be able to accurately propagate dirtiness for this key
             -- on the next build.
-            void $
+            liftIO $ void $
                 updateReverseDeps key db
                     (getResultDepsDefault mempty previousDeps)
                     deps
         _ -> pure ()
-    atomicallyNamed "compute and run hook" $ do
+    liftIO $ atomicallyNamed "compute and run hook" $ do
         runHook
         SMap.focus (updateStatus $ Clean res) key databaseValues
     pure res
@@ -247,18 +248,6 @@ getKeysAndVisitAge db = do
         getAge Result{resultVisited = Step s} = curr - s
     return keysWithVisitAge
 --------------------------------------------------------------------------------
--- Lazy IO trick
-
-data Box a = Box {fromBox :: a}
-
--- | Split an IO computation into an unsafe lazy value and a forcing computation
-splitIO :: IO a -> (IO (), a)
-splitIO act = do
-    let act2 = Box <$> act
-    let res = unsafePerformIO act2
-    (void $ evaluate res, fromBox res)
-
---------------------------------------------------------------------------------
 -- Reverse dependencies
 
 -- | Update the reverse dependencies of an Id
@@ -296,84 +285,5 @@ transitiveDirtySet database = flip State.execStateT mempty . traverse_ loop
             next <- lift $ atomically $ getReverseDependencies database x
             traverse_ loop (maybe mempty toListKeySet next)
 
---------------------------------------------------------------------------------
--- Asynchronous computations with cancellation
-
--- | A simple monad to implement cancellation on top of 'Async',
---   generalizing 'withAsync' to monadic scopes.
-newtype AIO a = AIO { unAIO :: ReaderT (IORef [Async ()]) IO a }
-  deriving newtype (Applicative, Functor, Monad, MonadIO)
-
--- | Run the monadic computation, cancelling all the spawned asyncs if an exception arises
-runAIO :: AIO a -> IO a
-runAIO (AIO act) = do
-    asyncs <- newIORef []
-    runReaderT act asyncs `onException` cleanupAsync asyncs
-
--- | Like 'async' but with built-in cancellation.
---   Returns an IO action to wait on the result.
-asyncWithCleanUp :: AIO a -> AIO (IO a)
-asyncWithCleanUp act = do
-    st <- AIO ask
-    io <- unliftAIO act
-    -- mask to make sure we keep track of the spawned async
-    liftIO $ uninterruptibleMask $ \restore -> do
-        a <- async $ restore io
-        atomicModifyIORef'_ st (void a :)
-        return $ wait a
-
-unliftAIO :: AIO a -> AIO (IO a)
-unliftAIO act = do
-    st <- AIO ask
-    return $ runReaderT (unAIO act) st
-
-newtype RunInIO = RunInIO (forall a. AIO a -> IO a)
-
-withRunInIO :: (RunInIO -> AIO b) -> AIO b
-withRunInIO k = do
-    st <- AIO ask
-    k $ RunInIO (\aio -> runReaderT (unAIO aio) st)
-
-cleanupAsync :: IORef [Async a] -> IO ()
--- mask to make sure we interrupt all the asyncs
-cleanupAsync ref = uninterruptibleMask $ \unmask -> do
-    asyncs <- atomicModifyIORef' ref ([],)
-    -- interrupt all the asyncs without waiting
-    mapM_ (\a -> throwTo (asyncThreadId a) AsyncCancelled) asyncs
-    -- Wait until all the asyncs are done
-    -- But if it takes more than 10 seconds, log to stderr
-    unless (null asyncs) $ do
-        let warnIfTakingTooLong = unmask $ forever $ do
-                sleep 10
-                traceM "cleanupAsync: waiting for asyncs to finish"
-        withAsync warnIfTakingTooLong $ \_ ->
-            mapM_ waitCatch asyncs
-
-data Wait
-    = Wait {justWait :: !(IO ())}
-    | Spawn {justWait :: !(IO ())}
-
-fmapWait :: (IO () -> IO ()) -> Wait -> Wait
-fmapWait f (Wait io)  = Wait (f io)
-fmapWait f (Spawn io) = Spawn (f io)
 
-waitOrSpawn :: Wait -> IO (Either (IO ()) (Async ()))
-waitOrSpawn (Wait io)  = pure $ Left io
-waitOrSpawn (Spawn io) = Right <$> async io
 
-waitConcurrently_ :: [Wait] -> AIO ()
-waitConcurrently_ [] = pure ()
-waitConcurrently_ [one] = liftIO $ justWait one
-waitConcurrently_ many = do
-    ref <- AIO ask
-    -- spawn the async computations.
-    -- mask to make sure we keep track of all the asyncs.
-    (asyncs, syncs) <- liftIO $ uninterruptibleMask $ \unmask -> do
-        waits <- liftIO $ traverse (waitOrSpawn . fmapWait unmask) many
-        let (syncs, asyncs) = partitionEithers waits
-        liftIO $ atomicModifyIORef'_ ref (asyncs ++)
-        return (asyncs, syncs)
-    -- work on the sync computations
-    liftIO $ sequence_ syncs
-    -- wait for the async computations before returning
-    liftIO $ traverse_ wait asyncs
diff --git a/hls-graph/src/Development/IDE/Graph/Internal/Types.hs b/hls-graph/src/Development/IDE/Graph/Internal/Types.hs
index 34bed42391..fae69da565 100644
--- a/hls-graph/src/Development/IDE/Graph/Internal/Types.hs
+++ b/hls-graph/src/Development/IDE/Graph/Internal/Types.hs
@@ -1,12 +1,13 @@
 {-# LANGUAGE CPP                #-}
 {-# LANGUAGE DeriveAnyClass     #-}
 {-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE LambdaCase         #-}
 {-# LANGUAGE RecordWildCards    #-}
 
 module Development.IDE.Graph.Internal.Types where
 
-import           Control.Concurrent.STM             (STM)
-import           Control.Monad                      ((>=>))
+import           Control.Concurrent.STM             (STM, modifyTVar')
+import           Control.Monad                      (forever, unless)
 import           Control.Monad.Catch
 import           Control.Monad.IO.Class
 import           Control.Monad.Trans.Reader
@@ -20,15 +21,26 @@ import           Data.IORef
 import           Data.List                          (intercalate)
 import           Data.Maybe
 import           Data.Typeable
+import           Debug.Trace                        (traceEventIO, traceM)
 import           Development.IDE.Graph.Classes
 import           Development.IDE.Graph.Internal.Key
+import           Development.IDE.WorkerThread       (DeliverStatus (..),
+                                                     TaskQueue, counTaskQueue,
+                                                     runInThreadStmInNewThreads)
 import           GHC.Conc                           (TVar, atomically)
 import           GHC.Generics                       (Generic)
 import qualified ListT
 import qualified StmContainers.Map                  as SMap
 import           StmContainers.Map                  (Map)
-import           System.Time.Extra                  (Seconds)
-import           UnliftIO                           (MonadUnliftIO)
+import           System.Time.Extra                  (Seconds, sleep)
+import           UnliftIO                           (Async (asyncThreadId),
+                                                     MonadUnliftIO,
+                                                     asyncExceptionFromException,
+                                                     asyncExceptionToException,
+                                                     readTVar, readTVarIO,
+                                                     throwTo, waitCatch,
+                                                     withAsync)
+import           UnliftIO.Concurrent                (ThreadId, myThreadId)
 
 #if !MIN_VERSION_base(4,18,0)
 import           Control.Applicative                (liftA2)
@@ -80,8 +92,8 @@ getDatabase :: Action Database
 getDatabase = Action $ asks actionDatabase
 
 -- | waitForDatabaseRunningKeysAction waits for all keys in the database to finish running.
-waitForDatabaseRunningKeysAction :: Action ()
-waitForDatabaseRunningKeysAction = getDatabase >>= liftIO . waitForDatabaseRunningKeys
+-- waitForDatabaseRunningKeysAction :: Action ()
+-- waitForDatabaseRunningKeysAction = getDatabase >>= liftIO . waitForDatabaseRunningKeys
 
 ---------------------------------------------------------------------
 -- DATABASE
@@ -91,12 +103,14 @@ data ShakeDatabase = ShakeDatabase !Int [Action ()] Database
 newtype Step = Step Int
     deriving newtype (Eq,Ord,Hashable,Show)
 
----------------------------------------------------------------------
--- Keys
-
-
 
+getShakeStep :: MonadIO m => ShakeDatabase -> m Step
+getShakeStep (ShakeDatabase _ _ db) = do
+    s <- readTVarIO $ databaseStep db
+    return s
 
+---------------------------------------------------------------------
+-- Keys
 newtype Value = Value Dynamic
 
 data KeyDetails = KeyDetails {
@@ -109,14 +123,74 @@ onKeyReverseDeps f it@KeyDetails{..} =
     it{keyReverseDeps = f keyReverseDeps}
 
 data Database = Database {
-    databaseExtra  :: Dynamic,
-    databaseRules  :: TheRules,
-    databaseStep   :: !(TVar Step),
-    databaseValues :: !(Map Key KeyDetails)
+    databaseExtra   :: Dynamic,
+
+    databaseThreads :: TVar [Async ()],
+    databaseQueue   :: TaskQueue (IO ()),
+
+    databaseRules   :: TheRules,
+    databaseStep    :: !(TVar Step),
+    databaseValues  :: !(Map Key KeyDetails)
     }
 
-waitForDatabaseRunningKeys :: Database -> IO ()
-waitForDatabaseRunningKeys = getDatabaseValues >=> mapM_ (waitRunning . snd)
+
+databaseGetActionQueueLength :: Database -> STM Int
+databaseGetActionQueueLength db = do
+    counTaskQueue (databaseQueue db)
+
+runInDataBase :: String -> Database -> [(IO result, Either SomeException result -> IO ())] -> STM ()
+runInDataBase title db acts = do
+    s <- getDataBaseStepInt db
+    runInThreadStmInNewThreads (getDataBaseStepInt db) (DeliverStatus s title) (databaseQueue db) (databaseThreads db) acts
+
+runOneInDataBase :: String -> Database -> IO result -> (SomeException -> IO ()) -> STM ()
+runOneInDataBase title db act handler = do
+  s <- getDataBaseStepInt db
+  runInThreadStmInNewThreads
+    (getDataBaseStepInt db)
+    (DeliverStatus s title)
+    (databaseQueue db)
+    (databaseThreads db)
+    [ ( act,
+        \case
+          Left e -> handler e
+          Right _ -> return ()
+      )
+    ]
+
+
+getDataBaseStepInt :: Database -> STM Int
+getDataBaseStepInt db = do
+    Step s <- readTVar $ databaseStep db
+    return s
+
+data AsyncParentKill = AsyncParentKill ThreadId Step
+    deriving (Show, Eq)
+
+instance Exception AsyncParentKill where
+  toException = asyncExceptionToException
+  fromException = asyncExceptionFromException
+
+shutDatabase :: Database -> IO ()
+shutDatabase Database{..} = uninterruptibleMask $ \unmask -> do
+    -- wait for all threads to finish
+    asyncs <- readTVarIO databaseThreads
+    step <- readTVarIO databaseStep
+    tid <- myThreadId
+    traceEventIO ("shutDatabase: cancelling " ++ show (length asyncs) ++ " asyncs, step " ++ show step)
+    mapM_ (\a -> throwTo (asyncThreadId a) $ AsyncParentKill tid step) asyncs
+    atomically $ modifyTVar' databaseThreads (const [])
+    -- Wait until all the asyncs are done
+    -- But if it takes more than 10 seconds, log to stderr
+    unless (null asyncs) $ do
+        let warnIfTakingTooLong = unmask $ forever $ do
+                sleep 10
+                traceM "cleanupAsync: waiting for asyncs to finish"
+        withAsync warnIfTakingTooLong $ \_ ->
+            mapM_ waitCatch asyncs
+
+-- waitForDatabaseRunningKeys :: Database -> IO ()
+-- waitForDatabaseRunningKeys = getDatabaseValues >=> mapM_ (waitRunning . snd)
 
 getDatabaseValues :: Database -> IO [(Key, Status)]
 getDatabaseValues = atomically
@@ -128,25 +202,28 @@ getDatabaseValues = atomically
 data Status
     = Clean !Result
     | Dirty (Maybe Result)
+    | Exception !Step !SomeException !(Maybe Result)
     | Running {
-        runningStep   :: !Step,
-        runningWait   :: !(IO ()),
-        runningResult :: Result,     -- LAZY
-        runningPrev   :: !(Maybe Result)
+        runningStep :: !Step,
+        -- runningWait   :: !(IO ()),
+        -- runningResult :: Result,     -- LAZY
+        runningPrev :: !(Maybe Result)
         }
 
 viewDirty :: Step -> Status -> Status
-viewDirty currentStep (Running s _ _ re) | currentStep /= s = Dirty re
+viewDirty currentStep (Running s re) | currentStep /= s = Dirty re
+viewDirty currentStep (Exception s _ re) | currentStep /= s = Dirty re
 viewDirty _ other = other
 
 getResult :: Status -> Maybe Result
 getResult (Clean re)           = Just re
 getResult (Dirty m_re)         = m_re
-getResult (Running _ _ _ m_re) = m_re -- watch out: this returns the previous result
+getResult (Running _ m_re)     = m_re -- watch out: this returns the previous result
+getResult (Exception _ _ m_re) = m_re
 
-waitRunning :: Status -> IO ()
-waitRunning Running{..} = runningWait
-waitRunning _           = return ()
+-- waitRunning :: Status -> IO ()
+-- waitRunning Running{..} = runningWait
+-- waitRunning _           = return ()
 
 data Result = Result {
     resultValue     :: !Value,
diff --git a/hls-graph/src/Development/IDE/WorkerThread.hs b/hls-graph/src/Development/IDE/WorkerThread.hs
new file mode 100644
index 0000000000..fd6a5c7695
--- /dev/null
+++ b/hls-graph/src/Development/IDE/WorkerThread.hs
@@ -0,0 +1,178 @@
+{-
+Module : Development.IDE.WorkerThread
+Author : @soulomoon
+SPDX-License-Identifier: Apache-2.0
+
+Description : This module provides an API for managing worker threads in the IDE.
+see Note [Serializing runs in separate thread]
+-}
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Development.IDE.WorkerThread
+  ( LogWorkerThread (..),
+    DeliverStatus(..),
+    withWorkerQueue,
+    awaitRunInThread,
+    TaskQueue,
+    writeTaskQueue,
+    withWorkerQueueSimple,
+    runInThreadStmInNewThreads,
+    isEmptyTaskQueue,
+    counTaskQueue,
+    awaitRunInThreadAtHead
+  ) where
+
+import           Control.Concurrent.Async (Async, async, withAsync)
+import           Control.Concurrent.STM
+import           Control.Exception.Safe   (MonadMask (..),
+                                           SomeException (SomeException),
+                                           finally, throw, try)
+import           Control.Monad.Cont       (ContT (ContT))
+import qualified Data.Text                as T
+
+import           Control.Concurrent
+import           Control.Exception        (catch)
+import           Control.Monad            (when)
+import           Prettyprinter
+
+data LogWorkerThread
+  = LogThreadEnding !T.Text
+  | LogThreadEnded !T.Text
+  | LogSingleWorkStarting !T.Text
+  | LogSingleWorkEnded !T.Text
+  | LogMainThreadId !T.Text !ThreadId
+  deriving (Show)
+
+instance Pretty LogWorkerThread where
+  pretty = \case
+    LogThreadEnding t -> "Worker thread ending:" <+> pretty t
+    LogThreadEnded t -> "Worker thread ended:" <+> pretty t
+    LogSingleWorkStarting t -> "Worker starting a unit of work: " <+> pretty t
+    LogSingleWorkEnded t -> "Worker ended a unit of work: " <+> pretty t
+    LogMainThreadId t tid -> "Main thread for" <+> pretty t <+> "is" <+> pretty (show tid)
+
+
+{-
+Note [Serializing runs in separate thread]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We often want to take long-running actions using some resource that cannot be shared.
+In this instance it is useful to have a queue of jobs to run using the resource.
+Like the db writes, session loading in session loader, shake session restarts.
+
+Originally we used various ways to implement this, but it was hard to maintain and error prone.
+Moreover, we can not stop these threads uniformly when we are shutting down the server.
+-}
+data TaskQueue a = TaskQueue (TQueue a)
+newTaskQueueIO :: IO (TaskQueue a)
+newTaskQueueIO = TaskQueue <$> newTQueueIO
+data ExitOrTask t = Exit | Task t
+type Logger = LogWorkerThread -> IO ()
+
+-- | 'withWorkerQueue' creates a new 'TQueue', and launches a worker
+-- thread which polls the queue for requests and runs the given worker
+-- function on them.
+withWorkerQueueSimple :: Logger -> T.Text -> ContT () IO (TaskQueue (IO ()))
+withWorkerQueueSimple log title = withWorkerQueue log title id
+withWorkerQueue :: Logger -> T.Text -> (t -> IO ()) -> ContT () IO (TaskQueue t)
+withWorkerQueue log title workerAction = ContT $ \mainAction -> do
+  tid <- myThreadId
+  log (LogMainThreadId title tid)
+  q <- newTaskQueueIO
+  -- Use a TMVar as a stop flag to coordinate graceful shutdown.
+  -- The worker thread checks this flag before dequeuing each job; if set, it exits immediately,
+  -- ensuring that no new work is started after shutdown is requested.
+  -- This mechanism is necessary because some downstream code may swallow async exceptions,
+  -- making 'cancel' unreliable for stopping the thread in all cases.
+  -- If 'cancel' does interrupt the thread (e.g., while blocked in STM or in a cooperative job),
+  -- the thread exits immediately and never checks the TMVar; in such cases, the stop flag is redundant.
+  b <- newEmptyTMVarIO
+  withAsync (writerThread q b) $ \_ -> do
+    mainAction q
+    -- if we want to debug the exact location the worker swallows an async exception, we can
+    -- temporarily comment out the `finally` clause.
+        `finally` atomically (putTMVar b ())
+    log (LogThreadEnding title)
+  log (LogThreadEnded title)
+  where
+    -- writerThread :: TaskQueue t -> TMVar () -> (forall a. IO a -> IO a) -> IO ()
+    writerThread q b =
+      -- See above: check stop flag before dequeuing, exit if set, otherwise run next job.
+      do
+        task <- atomically $ do
+          task <- tryReadTaskQueue q
+          isEm <- isEmptyTMVar b
+          case (isEm, task) of
+            (False, _)   -> return Exit -- stop flag set, exit
+            (_, Just t)  -> return $ Task t -- got a task, run it
+            (_, Nothing) -> retry -- no task, wait
+        case task of
+          Exit -> return ()
+          Task t -> do
+                log $ LogSingleWorkStarting title
+                workerAction t
+                log $ LogSingleWorkEnded title
+                writerThread q b
+
+
+-- | 'awaitRunInThread' queues up an 'IO' action to be run by a worker thread,
+-- and then blocks until the result is computed. If the action throws an
+-- non-async exception, it is rethrown in the calling thread.
+
+data DeliverStatus = DeliverStatus
+  { deliverStep   :: Int
+    , deliverName :: String
+  } deriving (Show)
+
+runInThreadStmInNewThreads :: STM Int -> DeliverStatus -> TaskQueue (IO ()) -> TVar [Async ()] -> [(IO result, Either SomeException result -> IO ())] -> STM ()
+runInThreadStmInNewThreads getStep deliver (TaskQueue q) tthreads acts = do
+  -- Take an action from TQueue, run it and
+  -- use barrier to wait for the result
+  writeTQueue q (uninterruptibleMask $ \restore -> do
+    curStep <- atomically getStep
+    -- traceM ("runInThreadStmInNewThreads: current step: " ++ show curStep ++ " deliver step: " ++ show deliver)
+    when (curStep == deliverStep deliver) $ do
+        syncs <- mapM (\(act, handler) ->
+            async (handler =<< (restore $ Right <$> act) `catch` \e@(SomeException _) -> return (Left e))) acts
+        atomically $ modifyTVar' tthreads (syncs++)
+    )
+
+awaitRunInThread :: TaskQueue (IO ()) -> IO result -> IO result
+awaitRunInThread (TaskQueue q) act = do
+  barrier <- newEmptyTMVarIO
+  -- Take an action from TQueue, run it and
+  -- use barrier to wait for the result
+  atomically $ writeTQueue q (try act >>= atomically . putTMVar barrier)
+  resultOrException <- atomically $ takeTMVar barrier
+  case resultOrException of
+    Left e  -> throw (e :: SomeException)
+    Right r -> return r
+
+awaitRunInThreadAtHead :: TaskQueue (IO ()) -> IO result -> IO result
+awaitRunInThreadAtHead (TaskQueue q) act = do
+  barrier <- newEmptyTMVarIO
+  -- Take an action from TQueue, run it and
+  -- use barrier to wait for the result
+  atomically $ unGetTQueue q (try act >>= atomically . putTMVar barrier)
+  resultOrException <- atomically $ takeTMVar barrier
+  case resultOrException of
+    Left e  -> throw (e :: SomeException)
+    Right r -> return r
+
+writeTaskQueue :: TaskQueue a -> a -> STM ()
+writeTaskQueue (TaskQueue q) = writeTQueue q
+
+tryReadTaskQueue :: TaskQueue a -> STM (Maybe a)
+tryReadTaskQueue (TaskQueue q) = tryReadTQueue q
+
+isEmptyTaskQueue :: TaskQueue a -> STM Bool
+isEmptyTaskQueue (TaskQueue q) = isEmptyTQueue q
+
+-- look and count the number of items in the queue
+-- do not remove them
+counTaskQueue :: TaskQueue a -> STM Int
+counTaskQueue (TaskQueue q) = do
+    xs <- flushTQueue q
+    mapM_ (unGetTQueue q) (reverse xs)
+    return $ length xs
+
diff --git a/hls-graph/test/ActionSpec.hs b/hls-graph/test/ActionSpec.hs
index 97ab5555ac..826d542e21 100644
--- a/hls-graph/test/ActionSpec.hs
+++ b/hls-graph/test/ActionSpec.hs
@@ -7,6 +7,7 @@ import           Control.Concurrent                      (MVar, readMVar)
 import qualified Control.Concurrent                      as C
 import           Control.Concurrent.STM
 import           Control.Monad.IO.Class                  (MonadIO (..))
+import           Control.Monad.Trans.Cont                (evalContT)
 import           Development.IDE.Graph                   (shakeOptions)
 import           Development.IDE.Graph.Database          (shakeNewDatabase,
                                                           shakeRunDatabase,
@@ -15,15 +16,28 @@ import           Development.IDE.Graph.Internal.Database (build, incDatabase)
 import           Development.IDE.Graph.Internal.Key
 import           Development.IDE.Graph.Internal.Types
 import           Development.IDE.Graph.Rule
+import           Development.IDE.WorkerThread            (TaskQueue,
+                                                          withWorkerQueueSimple)
 import           Example
 import qualified StmContainers.Map                       as STM
 import           Test.Hspec
 
 
 
+itInThread :: String -> (TaskQueue (IO ()) -> IO ()) -> SpecWith ()
+itInThread name ex = it name $ evalContT $ do
+    thread <- withWorkerQueueSimple (const $ return ()) "hls-graph test"
+    liftIO $ ex thread
+
+shakeRunDatabaseFromRight :: ShakeDatabase -> [Action a] -> IO [a]
+shakeRunDatabaseFromRight db as = do
+    res <- shakeRunDatabase db as
+    case sequence res of
+        Left e  -> error $ "shakeRunDatabaseFromRight: unexpected exception: " ++ show e
+        Right v -> return v
 spec :: Spec
 spec = do
-  describe "apply1" $ it "Test build update, Buggy dirty mechanism in hls-graph #4237" $ do
+  describe "apply1" $ itInThread "Test build update, Buggy dirty mechanism in hls-graph #4237" $ \q -> do
     let ruleStep1 :: MVar Int -> Rules ()
         ruleStep1 m = addRule $ \CountRule _old mode -> do
             -- depends on ruleSubBranch, it always changed if dirty
@@ -39,11 +53,11 @@ spec = do
                     return $ RunResult ChangedNothing "" r (return ())
     count <- C.newMVar 0
     count1 <- C.newMVar 0
-    db <- shakeNewDatabase shakeOptions $ do
+    db <- shakeNewDatabase q shakeOptions $ do
       ruleSubBranch count
       ruleStep1 count1
     -- bootstrapping the database
-    _ <- shakeRunDatabase db $ pure $ apply1 CountRule -- count = 1
+    _ <- shakeRunDatabaseFromRight db $ pure $ apply1 CountRule -- count = 1
     let child = newKey SubBranchRule
     let parent = newKey CountRule
     -- instruct to RunDependenciesChanged then CountRule should be recomputed
@@ -58,46 +72,46 @@ spec = do
     _res3 <- shakeRunDatabaseForKeys (Just [parent]) db [apply1 CountRule] -- count = 2
     c1 <- readMVar count1
     c1 `shouldBe` 2
-  describe "apply1" $ do
-    it "computes a rule with no dependencies" $ do
-      db <- shakeNewDatabase shakeOptions ruleUnit
-      res <- shakeRunDatabase db $
+  describe "apply1" $  do
+    itInThread "computes a rule with no dependencies" $ \q -> do
+      db <- shakeNewDatabase q shakeOptions ruleUnit
+      res <- shakeRunDatabaseFromRight db $
         pure $ apply1 (Rule @())
       res `shouldBe` [()]
-    it "computes a rule with one dependency" $ do
-      db <- shakeNewDatabase shakeOptions $ do
+    itInThread "computes a rule with one dependency" $ \q -> do
+      db <- shakeNewDatabase q shakeOptions $ do
         ruleUnit
         ruleBool
-      res <- shakeRunDatabase db $ pure $ apply1 Rule
+      res <- shakeRunDatabaseFromRight db $ pure $ apply1 Rule
       res `shouldBe` [True]
-    it "tracks direct dependencies" $ do
-      db@(ShakeDatabase _ _ theDb) <- shakeNewDatabase shakeOptions $ do
+    itInThread "tracks direct dependencies" $ \q -> do
+      db@(ShakeDatabase _ _ theDb) <- shakeNewDatabase q shakeOptions $ do
         ruleUnit
         ruleBool
       let theKey = Rule @Bool
-      res <- shakeRunDatabase db $
+      res <- shakeRunDatabaseFromRight db $
         pure $ apply1 theKey
       res `shouldBe` [True]
       Just (Clean res) <- lookup (newKey theKey) <$> getDatabaseValues theDb
       resultDeps res `shouldBe` ResultDeps [singletonKeySet $ newKey (Rule @())]
-    it "tracks reverse dependencies" $ do
-      db@(ShakeDatabase _ _ Database {..}) <- shakeNewDatabase shakeOptions $ do
+    itInThread "tracks reverse dependencies" $ \q -> do
+      db@(ShakeDatabase _ _ Database {..}) <- shakeNewDatabase q shakeOptions $ do
         ruleUnit
         ruleBool
       let theKey = Rule @Bool
-      res <- shakeRunDatabase db $
+      res <- shakeRunDatabaseFromRight db $
         pure $ apply1 theKey
       res `shouldBe` [True]
       Just KeyDetails {..} <- atomically $ STM.lookup (newKey (Rule @())) databaseValues
       keyReverseDeps `shouldBe` singletonKeySet (newKey theKey)
-    it "rethrows exceptions" $ do
-      db <- shakeNewDatabase shakeOptions $ addRule $ \(Rule :: Rule ()) _old _mode -> error "boom"
-      let res = shakeRunDatabase db $ pure $ apply1 (Rule @())
+    itInThread "rethrows exceptions" $ \q -> do
+      db <- shakeNewDatabase q shakeOptions $ addRule $ \(Rule :: Rule ()) _old _mode -> error "boom"
+      let res = shakeRunDatabaseFromRight db $ pure $ apply1 (Rule @())
       res `shouldThrow` anyErrorCall
-    it "computes a rule with branching dependencies does not invoke phantom dependencies #3423" $ do
+    itInThread "computes a rule with branching dependencies does not invoke phantom dependencies #3423" $ \q -> do
       cond <- C.newMVar True
       count <- C.newMVar 0
-      (ShakeDatabase _ _ theDb) <- shakeNewDatabase shakeOptions $ do
+      (ShakeDatabase _ _ theDb) <- shakeNewDatabase q shakeOptions $ do
         ruleUnit
         ruleCond cond
         ruleSubBranch count
@@ -116,15 +130,15 @@ spec = do
       countRes <- build theDb emptyStack [SubBranchRule]
       snd countRes `shouldBe` [1 :: Int]
 
-  describe "applyWithoutDependency" $ it "does not track dependencies" $ do
-    db@(ShakeDatabase _ _ theDb) <- shakeNewDatabase shakeOptions $ do
+  describe "applyWithoutDependency" $ itInThread "does not track dependencies" $ \q -> do
+    db@(ShakeDatabase _ _ theDb) <- shakeNewDatabase q shakeOptions $ do
       ruleUnit
       addRule $ \Rule _old _mode -> do
           [()] <- applyWithoutDependency [Rule]
           return $ RunResult ChangedRecomputeDiff "" True $ return ()
 
     let theKey = Rule @Bool
-    res <- shakeRunDatabase db $
+    res <- shakeRunDatabaseFromRight db $
       pure $ applyWithoutDependency [theKey]
     res `shouldBe` [[True]]
     Just (Clean res) <- lookup (newKey theKey) <$> getDatabaseValues theDb
diff --git a/hls-graph/test/DatabaseSpec.hs b/hls-graph/test/DatabaseSpec.hs
index 9061bfa89d..427dd2ceea 100644
--- a/hls-graph/test/DatabaseSpec.hs
+++ b/hls-graph/test/DatabaseSpec.hs
@@ -2,6 +2,9 @@
 
 module DatabaseSpec where
 
+import           Control.Exception                       (SomeException, throw)
+import           Control.Monad.IO.Class                  (MonadIO (..))
+import           Control.Monad.Trans.Cont                (evalContT)
 import           Development.IDE.Graph                   (newKey, shakeOptions)
 import           Development.IDE.Graph.Database          (shakeNewDatabase,
                                                           shakeRunDatabase)
@@ -9,28 +12,43 @@ import           Development.IDE.Graph.Internal.Action   (apply1)
 import           Development.IDE.Graph.Internal.Database (compute, incDatabase)
 import           Development.IDE.Graph.Internal.Rules    (addRule)
 import           Development.IDE.Graph.Internal.Types
+import           Development.IDE.WorkerThread
 import           Example
 import           System.Time.Extra                       (timeout)
 import           Test.Hspec
 
 
+itInThread :: String -> (TaskQueue (IO ()) -> IO ()) -> SpecWith ()
+itInThread name ex = it name $ evalContT $ do
+    thread <- withWorkerQueueSimple (const $ return ()) "hls-graph test"
+    liftIO $ ex thread
+
+exractException :: [Either SomeException ()] -> Maybe StackException
+exractException [] = Nothing
+exractException (Left e : _) | Just ne@StackException{} <- fromGraphException e = return ne
+exractException (_: xs) = exractException xs
+
+
 spec :: Spec
 spec = do
     describe "Evaluation" $ do
-        it "detects cycles" $ do
-            db <- shakeNewDatabase shakeOptions $ do
+        itInThread "detects cycles" $ \q -> do
+            db <- shakeNewDatabase q shakeOptions $ do
                 ruleBool
                 addRule $ \Rule _old _mode -> do
                     True <- apply1 (Rule @Bool)
                     return $ RunResult ChangedRecomputeDiff "" () (return ())
-            let res = shakeRunDatabase db $ pure $ apply1 (Rule @())
-            timeout 1 res `shouldThrow` \StackException{} -> True
+            res <- timeout 1 $ shakeRunDatabase db $ pure $ apply1 (Rule @())
+            let x = exractException =<< res
+            let throwStack x = case x
+                    of Just e  -> throw e
+                       Nothing -> error "Expected a StackException, got none"
+            throwStack x `shouldThrow` \StackException{} -> True
 
     describe "compute" $ do
-      it "build step and changed step updated correctly" $ do
-        (ShakeDatabase _ _ theDb) <- shakeNewDatabase shakeOptions $ do
+      itInThread "build step and changed step updated correctly" $ \q -> do
+        (ShakeDatabase _ _ theDb) <- shakeNewDatabase q shakeOptions $ do
           ruleStep
-
         let k = newKey $ Rule @()
         -- ChangedRecomputeSame
         r1@Result{resultChanged=rc1, resultBuilt=rb1} <- compute theDb emptyStack k RunDependenciesChanged Nothing
diff --git a/hls-plugin-api/src/Ide/Plugin/Config.hs b/hls-plugin-api/src/Ide/Plugin/Config.hs
index 4fee92c309..ecaf5f5d41 100644
--- a/hls-plugin-api/src/Ide/Plugin/Config.hs
+++ b/hls-plugin-api/src/Ide/Plugin/Config.hs
@@ -72,6 +72,7 @@ parsePluginConfig def = A.withObject "PluginConfig" $ \o -> PluginConfig
       <*> o .:? "diagnosticsOn"    .!= plcDiagnosticsOn def -- AZ
       <*> o .:? "hoverOn"          .!= plcHoverOn       def
       <*> o .:? "symbolsOn"        .!= plcSymbolsOn     def
+      <*> o .:? "signatureHelpOn"  .!= plcSignatureHelpOn def
       <*> o .:? "completionOn"     .!= plcCompletionOn  def
       <*> o .:? "renameOn"         .!= plcRenameOn      def
       <*> o .:? "selectionRangeOn" .!= plcSelectionRangeOn def
diff --git a/hls-plugin-api/src/Ide/Plugin/ConfigUtils.hs b/hls-plugin-api/src/Ide/Plugin/ConfigUtils.hs
index a7350ab344..f352cc179d 100644
--- a/hls-plugin-api/src/Ide/Plugin/ConfigUtils.hs
+++ b/hls-plugin-api/src/Ide/Plugin/ConfigUtils.hs
@@ -104,6 +104,7 @@ pluginsToDefaultConfig IdePlugins {..} =
           SMethod_TextDocumentRename               -> ["renameOn" A..= plcRenameOn]
           SMethod_TextDocumentHover                -> ["hoverOn" A..= plcHoverOn]
           SMethod_TextDocumentDocumentSymbol       -> ["symbolsOn" A..= plcSymbolsOn]
+          SMethod_TextDocumentSignatureHelp        -> ["signatureHelpOn" A..= plcSignatureHelpOn]
           SMethod_TextDocumentCompletion           -> ["completionOn" A..= plcCompletionOn]
           SMethod_TextDocumentPrepareCallHierarchy -> ["callHierarchyOn" A..= plcCallHierarchyOn]
           SMethod_TextDocumentSemanticTokensFull   -> ["semanticTokensOn" A..= plcSemanticTokensOn]
@@ -137,6 +138,7 @@ pluginsToVSCodeExtensionSchema IdePlugins {..} = A.object $ mconcat $ singlePlug
           SMethod_TextDocumentRename               -> [toKey' "renameOn" A..= schemaEntry "rename" plcRenameOn]
           SMethod_TextDocumentHover                -> [toKey' "hoverOn" A..= schemaEntry "hover" plcHoverOn]
           SMethod_TextDocumentDocumentSymbol       -> [toKey' "symbolsOn" A..= schemaEntry "symbols" plcSymbolsOn]
+          SMethod_TextDocumentSignatureHelp        -> [toKey' "signatureHelpOn" A..= schemaEntry "signature help" plcSignatureHelpOn]
           SMethod_TextDocumentCompletion           -> [toKey' "completionOn" A..= schemaEntry "completions" plcCompletionOn]
           SMethod_TextDocumentPrepareCallHierarchy -> [toKey' "callHierarchyOn" A..= schemaEntry "call hierarchy" plcCallHierarchyOn]
           SMethod_TextDocumentSemanticTokensFull   -> [toKey' "semanticTokensOn" A..= schemaEntry "semantic tokens" plcSemanticTokensOn]
diff --git a/hls-plugin-api/src/Ide/Types.hs b/hls-plugin-api/src/Ide/Types.hs
index 3a06656a77..314049b826 100644
--- a/hls-plugin-api/src/Ide/Types.hs
+++ b/hls-plugin-api/src/Ide/Types.hs
@@ -263,6 +263,7 @@ data PluginConfig =
       , plcDiagnosticsOn    :: !Bool
       , plcHoverOn          :: !Bool
       , plcSymbolsOn        :: !Bool
+      , plcSignatureHelpOn  :: !Bool
       , plcCompletionOn     :: !Bool
       , plcRenameOn         :: !Bool
       , plcSelectionRangeOn :: !Bool
@@ -281,6 +282,7 @@ instance Default PluginConfig where
       , plcDiagnosticsOn    = True
       , plcHoverOn          = True
       , plcSymbolsOn        = True
+      , plcSignatureHelpOn  = True
       , plcCompletionOn     = True
       , plcRenameOn         = True
       , plcSelectionRangeOn = True
@@ -290,7 +292,7 @@ instance Default PluginConfig where
       }
 
 instance ToJSON PluginConfig where
-    toJSON (PluginConfig g ch ca ih cl d h s c rn sr fr st cfg) = r
+    toJSON (PluginConfig g ch ca ih cl d h s sh c rn sr fr st cfg) = r
       where
         r = object [ "globalOn"         .= g
                    , "callHierarchyOn"  .= ch
@@ -300,6 +302,7 @@ instance ToJSON PluginConfig where
                    , "diagnosticsOn"    .= d
                    , "hoverOn"          .= h
                    , "symbolsOn"        .= s
+                   , "signatureHelpOn"  .= sh
                    , "completionOn"     .= c
                    , "renameOn"         .= rn
                    , "selectionRangeOn" .= sr
@@ -541,6 +544,9 @@ instance PluginMethod Request Method_TextDocumentHover where
 instance PluginMethod Request Method_TextDocumentDocumentSymbol where
   handlesRequest = pluginEnabledWithFeature plcSymbolsOn
 
+instance PluginMethod Request Method_TextDocumentSignatureHelp where
+  handlesRequest = pluginEnabledWithFeature plcSignatureHelpOn
+
 instance PluginMethod Request Method_CompletionItemResolve where
   -- See Note [Resolve in PluginHandlers]
   handlesRequest = pluginEnabledResolve plcCompletionOn
@@ -764,6 +770,9 @@ instance PluginRequestMethod Method_TextDocumentDocumentSymbol where
             si = SymbolInformation name' (ds ^. L.kind) Nothing parent (ds ^. L.deprecated) loc
         in [si] <> children'
 
+instance PluginRequestMethod Method_TextDocumentSignatureHelp where
+  combineResponses _ _ _ _ (x :| _) = x
+
 instance PluginRequestMethod Method_CompletionItemResolve where
   -- A resolve request should only have one response.
   -- See Note [Resolve in PluginHandlers]
diff --git a/hls-test-utils/hls-test-utils.cabal b/hls-test-utils/hls-test-utils.cabal
index 084de98534..a7d904e0d0 100644
--- a/hls-test-utils/hls-test-utils.cabal
+++ b/hls-test-utils/hls-test-utils.cabal
@@ -49,8 +49,8 @@ library
     , lsp
     , lsp-test                ^>=0.17
     , lsp-types               ^>=2.3
-    , neat-interpolation
     , safe-exceptions
+    , string-interpolate
     , tasty
     , tasty-expected-failure
     , tasty-golden
diff --git a/hls-test-utils/src/Development/IDE/Test.hs b/hls-test-utils/src/Development/IDE/Test.hs
index a1bd2dec0e..70390ad118 100644
--- a/hls-test-utils/src/Development/IDE/Test.hs
+++ b/hls-test-utils/src/Development/IDE/Test.hs
@@ -25,7 +25,6 @@ module Development.IDE.Test
   , flushMessages
   , waitForAction
   , getInterfaceFilesDir
-  , garbageCollectDirtyKeys
   , getFilesOfInterest
   , waitForTypecheck
   , waitForBuildQueue
@@ -218,8 +217,8 @@ waitForAction key TextDocumentIdentifier{_uri} =
 getInterfaceFilesDir :: TextDocumentIdentifier -> Session FilePath
 getInterfaceFilesDir TextDocumentIdentifier{_uri} = callTestPlugin (GetInterfaceFilesDir _uri)
 
-garbageCollectDirtyKeys :: CheckParents -> Int -> Session [String]
-garbageCollectDirtyKeys parents age = callTestPlugin (GarbageCollectDirtyKeys parents age)
+-- garbageCollectDirtyKeys :: CheckParents -> Int -> Session [String]
+-- garbageCollectDirtyKeys parents age = callTestPlugin (GarbageCollectDirtyKeys parents age)
 
 getStoredKeys :: Session [Text]
 getStoredKeys = callTestPlugin GetStoredKeys
diff --git a/hls-test-utils/src/Test/Hls.hs b/hls-test-utils/src/Test/Hls.hs
index 1193b2dd19..3ac4413860 100644
--- a/hls-test-utils/src/Test/Hls.hs
+++ b/hls-test-utils/src/Test/Hls.hs
@@ -357,7 +357,7 @@ goldenWithDocInTmpDir languageKind config plugin title tree path desc ext act =
 -- For example:
 --
 -- @
---  parameterisedCursorTest "Cursor Test" [trimming|
+--  parameterisedCursorTest "Cursor Test" [__i|
 --       foo = 2
 --        ^
 --       bar = 3
@@ -380,7 +380,7 @@ goldenWithDocInTmpDir languageKind config plugin title tree path desc ext act =
 -- TODO: Many Haskell and Cabal source may contain '^' characters for good reasons.
 -- We likely need a way to change the character for certain test cases in the future.
 --
--- The quasi quoter 'trimming' is very helpful to define such tests, as it additionally
+-- The quasi quoter '__i' is very helpful to define such tests, as it additionally
 -- allows to interpolate haskell values and functions. We reexport this quasi quoter
 -- for easier usage.
 parameterisedCursorTest :: (Show a, Eq a) => String -> T.Text -> [a] -> (T.Text -> PosPrefixInfo -> IO a) -> TestTree
@@ -770,7 +770,10 @@ runSessionWithTestConfig TestConfig{..} session =
 
     let plugins = testPluginDescriptor recorder <> lspRecorderPlugin
     timeoutOverride <- fmap read <$> lookupEnv "LSP_TIMEOUT"
-    let sconf' = testConfigSession { lspConfig = hlsConfigToClientConfig testLspConfig, messageTimeout = fromMaybe (messageTimeout defaultConfig) timeoutOverride}
+    let sconf' = testConfigSession { lspConfig = hlsConfigToClientConfig testLspConfig
+        , messageTimeout = fromMaybe (messageTimeout defaultConfig) timeoutOverride
+        , logStdErr = True
+        }
         arguments = testingArgs serverRoot recorderIde plugins
     server <- async $
         IDEMain.defaultMain (cmapWithPrio LogIDEMain recorderIde)
diff --git a/hls-test-utils/src/Test/Hls/FileSystem.hs b/hls-test-utils/src/Test/Hls/FileSystem.hs
index c93643badd..e349dbad3b 100644
--- a/hls-test-utils/src/Test/Hls/FileSystem.hs
+++ b/hls-test-utils/src/Test/Hls/FileSystem.hs
@@ -29,8 +29,12 @@ module Test.Hls.FileSystem
   , directProjectMulti
   , simpleCabalProject
   , simpleCabalProject'
+  , atomicFileWriteString
+  , atomicFileWriteStringUTF8
+  , atomicFileWriteText
   ) where
 
+import           Control.Exception           (onException)
 import           Data.Foldable               (traverse_)
 import qualified Data.Text                   as T
 import qualified Data.Text.IO                as T
@@ -38,6 +42,7 @@ import           Development.IDE             (NormalizedFilePath)
 import           Language.LSP.Protocol.Types (toNormalizedFilePath)
 import           System.Directory
 import           System.FilePath             as FP
+import           System.IO.Extra             (newTempFileWithin, writeFileUTF8)
 import           System.Process.Extra        (readProcess)
 
 -- ----------------------------------------------------------------------------
@@ -244,3 +249,25 @@ simpleCabalProject' :: [FileTree] -> [FileTree]
 simpleCabalProject' fps =
   [ simpleCabalCradle
   ] <> fps
+
+
+atomicFileWrite :: FilePath -> (FilePath -> IO a) -> IO a
+atomicFileWrite targetPath write = do
+  let dir = takeDirectory targetPath
+  createDirectoryIfMissing True dir
+  (tempFilePath, cleanUp) <- newTempFileWithin dir
+  (write tempFilePath >>= \x -> renameFile tempFilePath targetPath >> pure x)
+    `onException` cleanUp
+
+
+atomicFileWriteString :: FilePath -> String -> IO ()
+atomicFileWriteString targetPath content =
+  atomicFileWrite targetPath (flip writeFile content)
+
+atomicFileWriteStringUTF8 :: FilePath -> String -> IO ()
+atomicFileWriteStringUTF8 targetPath content =
+  atomicFileWrite targetPath (flip writeFileUTF8 content)
+
+atomicFileWriteText :: FilePath -> T.Text -> IO ()
+atomicFileWriteText targetPath content =
+    atomicFileWrite targetPath (flip T.writeFile content)
diff --git a/hls-test-utils/src/Test/Hls/Util.hs b/hls-test-utils/src/Test/Hls/Util.hs
index 98c795f8e0..cdb3c4de94 100644
--- a/hls-test-utils/src/Test/Hls/Util.hs
+++ b/hls-test-utils/src/Test/Hls/Util.hs
@@ -47,7 +47,7 @@ module Test.Hls.Util
     -- * Extract positions from input file.
     , extractCursorPositions
     , mkParameterisedLabel
-    , trimming
+    , __i
   )
 where
 
@@ -81,11 +81,11 @@ import           Test.Tasty.ExpectedFailure               (expectFailBecause,
 import           Test.Tasty.HUnit                         (assertFailure)
 
 import qualified Data.List                                as List
+import           Data.String.Interpolate                  (__i)
 import qualified Data.Text.Internal.Search                as T
 import qualified Data.Text.Utf16.Rope.Mixed               as Rope
 import           Development.IDE.Plugin.Completions.Logic (getCompletionPrefixFromRope)
 import           Development.IDE.Plugin.Completions.Types (PosPrefixInfo (..))
-import           NeatInterpolation                        (trimming)
 
 noLiteralCaps :: ClientCapabilities
 noLiteralCaps = def & L.textDocument ?~ textDocumentCaps
diff --git a/log copy.txt b/log copy.txt
new file mode 100644
index 0000000000..5da3744ff0
--- /dev/null
+++ b/log copy.txt	
@@ -0,0 +1,139 @@
+Run #3
+ThreadId 6 ghcide
+  diagnostics
+| 2025-08-1    Cancellation
+      edit header
+        GetHieAst: 9T14:55:44.590216Z | Info | Test Project located in directory: /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736
+ThreadId 7 | 2025-08-19T14:55:44.591607Z | Info | Heap statistics are not enabled (RTS option -T is needed)
+ThreadId 7 | 2025-08-19T14:55:44.594438Z | Info | Starting LSP server...
+  If you are seeing this in a terminal, you probably should have run WITHOUT the --lsp option!
+  PluginIds: [ test
+             , block-command
+             , ghcide-completions
+             , core
+             , ghcide-type-lenses
+             , LSPRecorderCallback
+             , ghcide-hover-and-symbols
+             , ghcide-core ]
+ThreadId 16 | 2025-08-19T14:55:44.594799Z | Info | Starting server
+ThreadId 16 | 2025-08-19T14:55:44.595197Z | Debug | LSP: set new config: {
+  "cabalFormattingProvider": "cabal-gild",
+  "checkParents": "CheckOnSave",
+  "checkProject": true,
+  "formattingProvider": "ormolu",
+  "maxCompletions": 40,
+  "plugin": {  },
+  "sessionLoading": "singleComponent"
+}
+ThreadId 16 | 2025-08-19T14:55:44.595437Z | Info | Registering IDE configuration: IdeConfiguration {workspaceFolders = fromList [NormalizedUri (-2250868254854792059) "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736"], clientSettings = hashed (Just (Object (fromList [("haskell",Object (fromList [("cabalFormattingProvider",String "cabal-gild"),("checkParents",String "CheckOnSave"),("checkProject",Bool True),("formattingProvider",String "ormolu"),("maxCompletions",Number 40.0),("plugin",Object (fromList [])),("sessionLoading",String "singleComponent")]))])))}
+ThreadId 16 | 2025-08-19T14:55:44.603799Z | Info | Started LSP server in 0.01s
+ThreadId 16 | 2025-08-19T14:55:44.603902Z | Debug | shouldRunSubset: True
+ThreadId 24 | 2025-08-19T14:55:44.603975Z | Debug | Initializing exports map from hiedb
+ThreadId 24 | 2025-08-19T14:55:44.604080Z | Debug | Done initializing exports map from hiedb. Size: 0
+ThreadId 20 | 2025-08-19T14:55:44.604735Z | Debug | Shake session initialized
+ThreadId 16 | 2025-08-19T14:55:44.605403Z | Debug | VFS: opening file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 16 | 2025-08-19T14:55:44.605775Z | Debug | LSP: set new config: {
+  "cabalFormattingProvider": "cabal-gild",
+  "checkParents": "CheckOnSave",
+  "checkProject": true,
+  "formattingProvider": "ormolu",
+  "maxCompletions": 40,
+  "plugin": {  },
+  "sessionLoading": "singleComponent"
+}
+ThreadId 26 | 2025-08-19T14:55:44.605883Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:44.605934Z | Debug | Configuration changed: Config {checkParents = CheckOnSave, checkProject = True, formattingProvider = "ormolu", cabalFormattingProvider = "cabal-gild", maxCompletions = 40, sessionLoading = PreferSingleComponentLoading, plugins = fromList []}
+ThreadId 21 | 2025-08-19T14:55:44.606008Z | Debug | Restarting build session due to config change
+Action Queue: []
+Keys: [GetClientSettings; ]
+Aborting previous build session took 0.00s
+ThreadId 30 | 2025-08-19T14:55:44.606131Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:44.606163Z | Debug | Set files of interst to
+    [ ( /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+    , Modified {firstOpen = True} ) ]
+ThreadId 21 | 2025-08-19T14:55:44.606229Z | Debug | Restarting build session due to /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs (modified)
+Action Queue: []
+Keys: [ GetClientSettings;
+      , GetModificationTime; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+      , IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs ]
+Aborting previous build session took 0.00s
+ThreadId 20 | 2025-08-19T14:55:44.606351Z | Debug | Opened text document: file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 39 | 2025-08-19T14:55:44.606579Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 42 | 2025-08-19T14:55:44.606750Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 22 | 2025-08-19T14:55:44.606794Z | Debug | Loop: getOptions for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 22 | 2025-08-19T14:55:44.606904Z | Info | Cradle path: Foo.hs
+ThreadId 22 | 2025-08-19T14:55:44.606952Z | Warning | No [cradle](https://github.com/mpickering/hie-bios#hie-bios) found for Foo.hs.
+Proceeding with [implicit cradle](https://hackage.haskell.org/package/implicit-hie).
+You should ignore this message, unless you see a 'Multi Cradle: No prefixes matched' error.
+ThreadId 46 | 2025-08-19T14:55:44.620269Z | Debug | Cradle: Cradle{ cradleRootDir = "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736", cradleOptsProg = CradleAction: Default}
+ThreadId 46 | 2025-08-19T14:55:44.620334Z | Info | invoking build tool to determine build flags (this may take some time depending on the cache)
+ThreadId 46 | 2025-08-19T14:55:44.683118Z | Debug | ghc --print-libdir
+ThreadId 46 | 2025-08-19T14:55:44.746399Z | Debug | ghc --numeric-version
+ThreadId 22 | 2025-08-19T14:55:44.746594Z | Debug | Session loading result: Right (ComponentOptions {componentOptions = [], componentRoot = "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736", componentDependencies = []},"/Users/ares/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/lib","9.12.2")
+ThreadId 22 | 2025-08-19T14:55:44.751250Z | Info | Interface files cache directory: /var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/.cache/ghcide/main-da39a3ee5e6b4b0d3255bfef95601890afd80709-da39a3ee5e6b4b0d3255bfef95601890afd80709
+ThreadId 22 | 2025-08-19T14:55:44.761208Z | Info | Making new HscEnv. In-place unit ids: [ main-da39a3ee5e6b4b0d3255bfef95601890afd80709 ]
+ThreadId 22 | 2025-08-19T14:55:44.766821Z | Debug | New component cache HscEnvEq: (([],Just HscEnvEq 5),fromList [])
+ThreadId 22 | 2025-08-19T14:55:44.767014Z | Info | New loaded files: [ /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs ]
+ThreadId 42 | 2025-08-19T14:55:44.767161Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 42 | 2025-08-19T14:55:44.767193Z | Info | Add dependency /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+[]
+ThreadId 71 | 2025-08-19T14:55:44.767277Z | Info | Modification time for "v1"
+ThreadId 71 | 2025-08-19T14:55:44.767314Z | Info | Modification time for "v1.1"
+ThreadId 33 | 2025-08-19T14:55:44.767455Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:44.767514Z | Debug | Known files updated:
+  fromList [(TargetFile NormalizedFilePath "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs",fromList ["/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs"])]
+ThreadId 21 | 2025-08-19T14:55:44.769748Z | Debug | Restarting build session due to new component
+Action Queue: [ WaitForIdeRule TypeCheck Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs"} ]
+Keys: [ IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+      , GhcSessionIO;
+      , GetKnownTargets;  ]
+Aborting previous build session took 0.00s
+ThreadId 83 | 2025-08-19T14:55:44.769932Z | Debug | Finished: InitialLoad Took: 0.00s
+ThreadId 84 | 2025-08-19T14:55:44.769935Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 87 | 2025-08-19T14:55:44.770101Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 87 | 2025-08-19T14:55:44.770141Z | Info | Add dependency /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+[]
+ThreadId 84 | 2025-08-19T14:55:44.779362Z | Warning | Typechecking file mid /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 84 | 2025-08-19T14:55:44.787260Z | Warning | Typechecking file end /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 81 | 2025-08-19T14:55:44.788775Z | Debug | Finished: WaitForIdeRule TypeCheck Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs"} Took: 0.02s
+ThreadId 16 | 2025-08-19T14:55:44.990428Z | Error | LSP: no handler for: "non-existent-method"
+ThreadId 78 | 2025-08-19T14:55:44.992303Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:44.992398Z | Debug | Set files of interst to
+    [ ( /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+    , Modified {firstOpen = False} ) ]
+ThreadId 21 | 2025-08-19T14:55:44.992559Z | Debug | Restarting build session due to /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs (modified)
+Action Queue: []
+Keys: [ GetModificationTime; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+      , IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs ]
+Aborting previous build session took 0.00s
+ThreadId 20 | 2025-08-19T14:55:44.992780Z | Debug | Modified text document: file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 132 | 2025-08-19T14:55:44.993293Z | Info | Modification time for "v1"
+ThreadId 132 | 2025-08-19T14:55:44.993379Z | Info | Modification time for "v1.1"
+ThreadId 128 | 2025-08-19T14:55:44.994761Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 126 | 2025-08-19T14:55:44.995047Z | Debug | Finished: WaitForIdeRule GetHieAst Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs"} Took: 0.00s
+ThreadId 121 | 2025-08-19T14:55:44.996016Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:44.996055Z | Debug | Restarting build session due to /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs (modified)
+Action Queue: []
+Keys: [ GetModificationTime; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs ]
+Aborting previous build session took 0.00s
+ThreadId 20 | 2025-08-19T14:55:44.996292Z | Debug | Modified text document: file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 153 | 2025-08-19T14:55:45.005864Z | Info | Modification time for "v1"
+ThreadId 153 | 2025-08-19T14:55:45.005981Z | Info | Modification time for "v1.1"
+ThreadId 149 | 2025-08-19T14:55:45.007173Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 149 | 2025-08-19T14:55:45.007522Z | Warning | Typechecking file mid /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 149 | 2025-08-19T14:55:45.008236Z | Warning | Typechecking file end /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs
+ThreadId 148 | 2025-08-19T14:55:45.008442Z | Debug | Finished: WaitForIdeRule TypeCheck Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-26398544736/Foo.hs"} Took: 0.01s
+ThreadId 16 | 2025-08-19T14:55:45.211497Z | Error | LSP: no handler for: "non-existent-method"
+ThreadId 16 | 2025-08-19T14:55:45.717804Z | Info | LSP: received shutdown
+ThreadId 16 | 2025-08-19T14:55:45.717897Z | Debug | Received shutdown message
+ThreadId 143 | 2025-08-19T14:55:45.717964Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 6 | 2025-08-19T14:55:45.718622Z | Debug | Cleaned up temporary directory
+        GetHieAst: OK (1.13s)
+
+All 1 tests passed (1.13s)
diff --git a/log.txt b/log.txt
new file mode 100644
index 0000000000..86afac3e96
--- /dev/null
+++ b/log.txt
@@ -0,0 +1,111 @@
+Run #4
+Thghcide
+  diagnostics
+    Cancellation
+      edit header
+readId 6 |         GetHieAst: 2025-08-19T14:55:45.773048Z | Info | Test Project located in directory: /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736
+ThreadId 7 | 2025-08-19T14:55:45.774261Z | Info | Heap statistics are not enabled (RTS option -T is needed)
+ThreadId 7 | 2025-08-19T14:55:45.776775Z | Info | Starting LSP server...
+  If you are seeing this in a terminal, you probably should have run WITHOUT the --lsp option!
+  PluginIds: [ test
+             , block-command
+             , ghcide-completions
+             , core
+             , ghcide-type-lenses
+             , LSPRecorderCallback
+             , ghcide-hover-and-symbols
+             , ghcide-core ]
+ThreadId 16 | 2025-08-19T14:55:45.777036Z | Info | Starting server
+ThreadId 16 | 2025-08-19T14:55:45.777814Z | Debug | LSP: set new config: {
+  "cabalFormattingProvider": "cabal-gild",
+  "checkParents": "CheckOnSave",
+  "checkProject": true,
+  "formattingProvider": "ormolu",
+  "maxCompletions": 40,
+  "plugin": {  },
+  "sessionLoading": "singleComponent"
+}
+ThreadId 16 | 2025-08-19T14:55:45.778159Z | Info | Registering IDE configuration: IdeConfiguration {workspaceFolders = fromList [NormalizedUri (-4077115142264691803) "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736"], clientSettings = hashed (Just (Object (fromList [("haskell",Object (fromList [("cabalFormattingProvider",String "cabal-gild"),("checkParents",String "CheckOnSave"),("checkProject",Bool True),("formattingProvider",String "ormolu"),("maxCompletions",Number 40.0),("plugin",Object (fromList [])),("sessionLoading",String "singleComponent")]))])))}
+ThreadId 16 | 2025-08-19T14:55:45.785776Z | Info | Started LSP server in 0.01s
+ThreadId 16 | 2025-08-19T14:55:45.785884Z | Debug | shouldRunSubset: True
+ThreadId 24 | 2025-08-19T14:55:45.785963Z | Debug | Initializing exports map from hiedb
+ThreadId 24 | 2025-08-19T14:55:45.786047Z | Debug | Done initializing exports map from hiedb. Size: 0
+ThreadId 20 | 2025-08-19T14:55:45.786560Z | Debug | Shake session initialized
+ThreadId 16 | 2025-08-19T14:55:45.786658Z | Debug | VFS: opening file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 16 | 2025-08-19T14:55:45.786871Z | Debug | LSP: set new config: {
+  "cabalFormattingProvider": "cabal-gild",
+  "checkParents": "CheckOnSave",
+  "checkProject": true,
+  "formattingProvider": "ormolu",
+  "maxCompletions": 40,
+  "plugin": {  },
+  "sessionLoading": "singleComponent"
+}
+ThreadId 26 | 2025-08-19T14:55:45.786890Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:45.787076Z | Debug | Set files of interst to
+    [ ( /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+    , Modified {firstOpen = True} ) ]
+ThreadId 21 | 2025-08-19T14:55:45.787154Z | Debug | Restarting build session due to /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs (modified)
+Action Queue: []
+Keys: [ GetModificationTime; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+      , IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs ]
+Aborting previous build session took 0.00s
+ThreadId 20 | 2025-08-19T14:55:45.787225Z | Debug | Opened text document: file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 30 | 2025-08-19T14:55:45.787249Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:45.787316Z | Debug | Configuration changed: Config {checkParents = CheckOnSave, checkProject = True, formattingProvider = "ormolu", cabalFormattingProvider = "cabal-gild", maxCompletions = 40, sessionLoading = PreferSingleComponentLoading, plugins = fromList []}
+ThreadId 21 | 2025-08-19T14:55:45.787402Z | Debug | Restarting build session due to config change
+Action Queue: []
+Keys: [ GetModificationTime; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+      , IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+      , GetClientSettings;  ]
+Aborting previous build session took 0.00s
+ThreadId 39 | 2025-08-19T14:55:45.787576Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 42 | 2025-08-19T14:55:45.787771Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 22 | 2025-08-19T14:55:45.787834Z | Debug | Loop: getOptions for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 22 | 2025-08-19T14:55:45.787956Z | Info | Cradle path: Foo.hs
+ThreadId 22 | 2025-08-19T14:55:45.788018Z | Warning | No [cradle](https://github.com/mpickering/hie-bios#hie-bios) found for Foo.hs.
+Proceeding with [implicit cradle](https://hackage.haskell.org/package/implicit-hie).
+You should ignore this message, unless you see a 'Multi Cradle: No prefixes matched' error.
+ThreadId 46 | 2025-08-19T14:55:45.802993Z | Debug | Cradle: Cradle{ cradleRootDir = "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736", cradleOptsProg = CradleAction: Default}
+ThreadId 46 | 2025-08-19T14:55:45.803066Z | Info | invoking build tool to determine build flags (this may take some time depending on the cache)
+ThreadId 46 | 2025-08-19T14:55:45.868167Z | Debug | ghc --print-libdir
+ThreadId 46 | 2025-08-19T14:55:45.932486Z | Debug | ghc --numeric-version
+ThreadId 22 | 2025-08-19T14:55:45.932641Z | Debug | Session loading result: Right (ComponentOptions {componentOptions = [], componentRoot = "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736", componentDependencies = []},"/Users/ares/.ghcup/ghc/9.12.2/lib/ghc-9.12.2/lib","9.12.2")
+ThreadId 22 | 2025-08-19T14:55:45.936702Z | Info | Interface files cache directory: /var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/.cache/ghcide/main-da39a3ee5e6b4b0d3255bfef95601890afd80709-da39a3ee5e6b4b0d3255bfef95601890afd80709
+ThreadId 22 | 2025-08-19T14:55:45.946351Z | Info | Making new HscEnv. In-place unit ids: [ main-da39a3ee5e6b4b0d3255bfef95601890afd80709 ]
+ThreadId 22 | 2025-08-19T14:55:45.956408Z | Debug | New component cache HscEnvEq: (([],Just HscEnvEq 5),fromList [])
+ThreadId 22 | 2025-08-19T14:55:45.956697Z | Info | New loaded files: [ /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs ]
+ThreadId 42 | 2025-08-19T14:55:45.957872Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 42 | 2025-08-19T14:55:45.957948Z | Info | Add dependency /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+[]
+ThreadId 70 | 2025-08-19T14:55:45.959426Z | Info | Modification time for "v1"
+ThreadId 70 | 2025-08-19T14:55:45.959473Z | Info | Modification time for "v1.1"
+ThreadId 37 | 2025-08-19T14:55:45.959782Z | Debug | Finished build session
+AsyncCancelled
+ThreadId 21 | 2025-08-19T14:55:45.959915Z | Debug | Known files updated:
+  fromList [(TargetFile NormalizedFilePath "/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs",fromList ["/private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs"])]
+ThreadId 21 | 2025-08-19T14:55:45.959969Z | Debug | Restarting build session due to new component
+Action Queue: [ WaitForIdeRule TypeCheck Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs"} ]
+Keys: [ IsFileOfInterest; /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+      , GhcSessionIO;
+      , GetKnownTargets;  ]
+Aborting previous build session took 0.00s
+ThreadId 83 | 2025-08-19T14:55:45.960398Z | Debug | Finished: InitialLoad Took: 0.00s
+ThreadId 84 | 2025-08-19T14:55:45.984810Z | Warning | Typechecking file start /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 88 | 2025-08-19T14:55:45.985135Z | Debug | Looking up session cache for /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 88 | 2025-08-19T14:55:45.985189Z | Info | Add dependency /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+[]
+ThreadId 84 | 2025-08-19T14:55:45.992785Z | Warning | Typechecking file mid /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 84 | 2025-08-19T14:55:46.004387Z | Warning | Typechecking file end /private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs
+ThreadId 81 | 2025-08-19T14:55:46.004765Z | Debug | Finished: WaitForIdeRule TypeCheck Uri {getUri = "file:///private/var/folders/36/_743psv11gv2wrj9dclrpd500000gn/T/hls-test-root/extra-dir-35327754736/Foo.hs"} Took: 0.04s
+ThreadId 16 | 2025-08-19T14:55:46.207056Z | Error | LSP: no handler for: "non-existent-method"
+ThreadId 16 | 2025-08-19T14:55:46.207691Z | Error | LSP: no handler for: "non-existent-method"
+ThreadId 16 | 2025-08-19T14:55:46.208630Z | Info | LSP: received shutdown
+ThreadId 16 | 2025-08-19T14:55:46.208805Z | Debug | Received shutdown message
+ThreadId 78 | 2025-08-19T14:55:46.209199Z | Debug | Finished build session
+AsyncCancelled
+        GetHieAst: FAIL (0.44s)
+          ghcide-test/exe/DiagnosticTests.hs:560:
+          Could not find (DiagnosticSeverity_Warning,(3,0),"Top-level binding",Just "GHC-38417",Nothing) in []
diff --git a/plugins/hls-cabal-plugin/test/Completer.hs b/plugins/hls-cabal-plugin/test/Completer.hs
index ab7165b1ac..1abaacaacf 100644
--- a/plugins/hls-cabal-plugin/test/Completer.hs
+++ b/plugins/hls-cabal-plugin/test/Completer.hs
@@ -392,39 +392,39 @@ extract item = case item ^. L.textEdit of
   _            -> error ""
 
 importTestData :: T.Text
-importTestData = [trimming|
-cabal-version:      3.0
-name:               hls-cabal-plugin
-version:            0.1.0.0
-synopsis:
-homepage:
-license:            MIT
-license-file:       LICENSE
-author:             Fendor
-maintainer:         fendor@posteo.de
-category:           Development
-extra-source-files: CHANGELOG.md
+importTestData = [__i|
+  cabal-version:      3.0
+  name:               hls-cabal-plugin
+  version:            0.1.0.0
+  synopsis:
+  homepage:
+  license:            MIT
+  license-file:       LICENSE
+  author:             Fendor
+  maintainer:         fendor@posteo.de
+  category:           Development
+  extra-source-files: CHANGELOG.md
 
-common defaults
-  default-language: GHC2021
-  -- Should have been in GHC2021, an oversight
-  default-extensions: ExplicitNamespaces
+  common defaults
+    default-language: GHC2021
+    -- Should have been in GHC2021, an oversight
+    default-extensions: ExplicitNamespaces
 
-common test-defaults
-  ghc-options: -threaded -rtsopts -with-rtsopts=-N
+  common test-defaults
+    ghc-options: -threaded -rtsopts -with-rtsopts=-N
 
-library
-    import:
-            ^
-    exposed-modules:  IDE.Plugin.Cabal
-    build-depends:    base ^>=4.14.3.0
-    hs-source-dirs:   src
-    default-language: Haskell2010
+  library
+      import:
+              ^
+      exposed-modules:  IDE.Plugin.Cabal
+      build-depends:    base ^>=4.14.3.0
+      hs-source-dirs:   src
+      default-language: Haskell2010
 
-common notForLib
-  default-language: GHC2021
+  common notForLib
+    default-language: GHC2021
 
-test-suite tests
-  import:
-          ^
+  test-suite tests
+    import:
+            ^
 |]
diff --git a/plugins/hls-cabal-plugin/test/Context.hs b/plugins/hls-cabal-plugin/test/Context.hs
index 8e6176bc5b..00d13b08f8 100644
--- a/plugins/hls-cabal-plugin/test/Context.hs
+++ b/plugins/hls-cabal-plugin/test/Context.hs
@@ -217,93 +217,93 @@ getContextTests =
 -- ------------------------------------------------------------------------
 
 libraryStanzaData :: T.Text
-libraryStanzaData = [trimming|
-cabal-version:      3.0
-name:               simple-cabal
-library
-    default-language: Haskell98
-    build-depends:
+libraryStanzaData = [__i|
+    cabal-version:      3.0
+    name:               simple-cabal
+    library
+        default-language: Haskell98
+        build-depends:
 
-ma
+    ma
 |]
 
 executableStanzaData :: T.Text
-executableStanzaData = [trimming|
-cabal-version:      3.0
-name:               simple-cabal
-executable exeName
-    default-language: Haskell2010
-    hs-source-dirs: test/preprocessor
+executableStanzaData = [__i|
+    cabal-version:      3.0
+    name:               simple-cabal
+    executable exeName
+        default-language: Haskell2010
+        hs-source-dirs: test/preprocessor
 |]
 
 topLevelData :: T.Text
-topLevelData = [trimming|
-cabal-version:      3.0
-name:
+topLevelData = [__i|
+    cabal-version:      3.0
+    name:
 
 
 
-          eee
+              eee
 |]
 
 conditionalData :: T.Text
-conditionalData = [trimming|
-cabal-version:      3.0
-name:               simple-cabal
-library
-    if os(windows)
-       buildable:
-    elif os(linux)
-       buildable:
-    else
-       buildable:
+conditionalData = [__i|
+    cabal-version:      3.0
+    name:               simple-cabal
+    library
+        if os(windows)
+           buildable:
+        elif os(linux)
+           buildable:
+        else
+           buildable:
 |]
 multiLineOptsData :: T.Text
-multiLineOptsData = [trimming|
-cabal-version:      3.0
-name:
+multiLineOptsData = [__i|
+    cabal-version:      3.0
+    name:
 
 
-library
-    build-depends:
-        base,
+    library
+        build-depends:
+            base,
 
-        text ,
+            text ,
 |]
 
 multiPositionTestData :: T.Text
-multiPositionTestData = [trimming|
-cabal-version:      3.4
-       ^             ^
-category:           Development
-^
-name:               haskell-language-server
-description:
-  Please see the README on GitHub at <https://github.com/haskell/haskell-language-server#readme>
+multiPositionTestData = [__i|
+    cabal-version:      3.4
+           ^             ^
+    category:           Development
     ^
-extra-source-files:
-  README.md
-  ChangeLog.md
-  test/testdata/**/*.project
-  test/testdata/**/*.cabal
-  test/testdata/**/*.yaml
-  test/testdata/**/*.hs
-  test/testdata/**/*.json
-    ^
-  -- These globs should only match test/testdata
-  plugins/**/*.project
+    name:               haskell-language-server
+    description:
+      Please see the README on GitHub at <https://github.com/haskell/haskell-language-server\#readme>
+        ^
+    extra-source-files:
+      README.md
+      ChangeLog.md
+      test/testdata/**/*.project
+      test/testdata/**/*.cabal
+      test/testdata/**/*.yaml
+      test/testdata/**/*.hs
+      test/testdata/**/*.json
+        ^
+      -- These globs should only match test/testdata
+      plugins/**/*.project
 
-source-repository head
-     ^              ^   ^
-  type:     git
-    ^    ^    ^  ^
-  location: https://github.com/haskell/haskell-language-server
+    source-repository head
+         ^              ^   ^
+      type:     git
+        ^    ^    ^  ^
+      location: https://github.com/haskell/haskell-language-server
 
-  ^
-common cabalfmt
+      ^
+    common cabalfmt
 
-  ^
-  build-depends: haskell-language-server:hls-cabal-fmt-plugin
-    ^            ^
-  cpp-options: -Dhls_cabalfmt
+      ^
+      build-depends: haskell-language-server:hls-cabal-fmt-plugin
+        ^            ^
+      cpp-options: -Dhls_cabalfmt
 |]
diff --git a/plugins/hls-cabal-plugin/test/Main.hs b/plugins/hls-cabal-plugin/test/Main.hs
index 43794e753d..5570598a37 100644
--- a/plugins/hls-cabal-plugin/test/Main.hs
+++ b/plugins/hls-cabal-plugin/test/Main.hs
@@ -292,7 +292,7 @@ reloadOnCabalChangeTests = testGroup "Reload on .cabal changes"
         cabalDoc <- openDoc "simple-reload.cabal" "cabal"
         skipManyTill anyMessage cabalKickDone
         saveDoc cabalDoc
-            [trimming|
+            [__i|
             cabal-version:      3.4
             name:               simple-reload
             version:            0.1.0.0
diff --git a/plugins/hls-class-plugin/src/Ide/Plugin/Class/Types.hs b/plugins/hls-class-plugin/src/Ide/Plugin/Class/Types.hs
index 1669aba43d..ee2a3fda7f 100644
--- a/plugins/hls-class-plugin/src/Ide/Plugin/Class/Types.hs
+++ b/plugins/hls-class-plugin/src/Ide/Plugin/Class/Types.hs
@@ -226,9 +226,8 @@ getInstanceBindTypeSigsRule recorder = do
             whenMaybe (isBindingName name) $ do
                 env <- tcInitTidyEnv
 #if MIN_VERSION_ghc(9,11,0)
-                let ty =
+                let ty = tidyOpenType env (idType id)
 #else
-                let (_, ty) =
+                let (_, ty) = tidyOpenType env (idType id)
 #endif
-                              tidyOpenType env (idType id)
                 pure $ InstanceBindTypeSig name ty
diff --git a/plugins/hls-pragmas-plugin/src/Ide/Plugin/Pragmas.hs b/plugins/hls-pragmas-plugin/src/Ide/Plugin/Pragmas.hs
index 23bfd727cf..c395feba9e 100644
--- a/plugins/hls-pragmas-plugin/src/Ide/Plugin/Pragmas.hs
+++ b/plugins/hls-pragmas-plugin/src/Ide/Plugin/Pragmas.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE LambdaCase            #-}
 {-# LANGUAGE MultiWayIf            #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE ViewPatterns          #-}
@@ -27,8 +28,13 @@ import qualified Data.Text                                as T
 import           Development.IDE                          hiding (line)
 import           Development.IDE.Core.Compile             (sourceParser,
                                                            sourceTypecheck)
+import           Development.IDE.Core.FileStore           (getVersionedTextDoc)
 import           Development.IDE.Core.PluginUtils
 import           Development.IDE.GHC.Compat
+import           Development.IDE.GHC.Compat.Error         (GhcHint (SuggestExtension),
+                                                           LanguageExtensionHint (..),
+                                                           diagnosticHints,
+                                                           msgEnvelopeErrorL)
 import           Development.IDE.Plugin.Completions       (ghcideCompletionsPluginPriority)
 import           Development.IDE.Plugin.Completions.Logic (getCompletionPrefixFromRope)
 import           Development.IDE.Plugin.Completions.Types (PosPrefixInfo (..))
@@ -69,13 +75,33 @@ data Pragma = LangExt T.Text | OptGHC T.Text
   deriving (Show, Eq, Ord)
 
 suggestPragmaProvider :: PluginMethodHandler IdeState 'LSP.Method_TextDocumentCodeAction
-suggestPragmaProvider = mkCodeActionProvider suggest
+suggestPragmaProvider = if ghcVersion /= GHC96 then
+    mkCodeActionProvider suggestAddPragma
+    else mkCodeActionProvider96 suggestAddPragma96
 
 suggestDisableWarningProvider :: PluginMethodHandler IdeState 'LSP.Method_TextDocumentCodeAction
 suggestDisableWarningProvider = mkCodeActionProvider $ const suggestDisableWarning
 
-mkCodeActionProvider :: (Maybe DynFlags -> Diagnostic -> [PragmaEdit]) -> PluginMethodHandler IdeState 'LSP.Method_TextDocumentCodeAction
+mkCodeActionProvider :: (Maybe DynFlags -> FileDiagnostic -> [PragmaEdit]) -> PluginMethodHandler IdeState 'LSP.Method_TextDocumentCodeAction
 mkCodeActionProvider mkSuggest state _plId
+  (LSP.CodeActionParams _ _ docId@LSP.TextDocumentIdentifier{ _uri = uri } caRange _) = do
+    verTxtDocId <- liftIO $ runAction "classplugin.codeAction.getVersionedTextDoc" state $ getVersionedTextDoc docId
+    normalizedFilePath <- getNormalizedFilePathE (verTxtDocId ^. L.uri)
+    -- ghc session to get some dynflags even if module isn't parsed
+    (hscEnv -> hsc_dflags -> sessionDynFlags, _) <-
+      runActionE "Pragmas.GhcSession" state $ useWithStaleE GhcSession normalizedFilePath
+    fileContents <- liftIO $ runAction "Pragmas.GetFileContents" state $ getFileContents normalizedFilePath
+    parsedModule <- liftIO $ runAction "Pragmas.GetParsedModule" state $ getParsedModule normalizedFilePath
+    let parsedModuleDynFlags = ms_hspp_opts . pm_mod_summary <$> parsedModule
+        nextPragmaInfo = Pragmas.getNextPragmaInfo sessionDynFlags fileContents
+    activeDiagnosticsInRange (shakeExtras state) normalizedFilePath caRange >>= \case
+        Nothing -> pure $ LSP.InL []
+        Just fileDiags -> do
+            let actions = concatMap (mkSuggest parsedModuleDynFlags) fileDiags
+            pure $ LSP.InL $ pragmaEditToAction uri nextPragmaInfo <$> nubOrdOn snd actions
+
+mkCodeActionProvider96 :: (Maybe DynFlags -> Diagnostic -> [PragmaEdit]) -> PluginMethodHandler IdeState 'LSP.Method_TextDocumentCodeAction
+mkCodeActionProvider96 mkSuggest state _plId
   (LSP.CodeActionParams _ _ LSP.TextDocumentIdentifier{ _uri = uri } _ (LSP.CodeActionContext diags _monly _)) = do
     normalizedFilePath <- getNormalizedFilePathE uri
     -- ghc session to get some dynflags even if module isn't parsed
@@ -89,7 +115,6 @@ mkCodeActionProvider mkSuggest state _plId
     pure  $ LSP.InL $ pragmaEditToAction uri nextPragmaInfo <$> pedits
 
 
-
 -- | Add a Pragma to the given URI at the top of the file.
 -- It is assumed that the pragma name is a valid pragma,
 -- thus, not validated.
@@ -108,22 +133,17 @@ pragmaEditToAction uri Pragmas.NextPragmaInfo{ nextPragmaLine, lineSplitTextEdit
          , let LSP.TextEdit{ _range, _newText } = insertTextEdit ->
              [LSP.TextEdit _range (render p <> _newText), deleteTextEdit]
          | otherwise -> [LSP.TextEdit pragmaInsertRange (render p)]
-
     edit =
       LSP.WorkspaceEdit
         (Just $ M.singleton uri textEdits)
         Nothing
         Nothing
 
-suggest :: Maybe DynFlags -> Diagnostic -> [PragmaEdit]
-suggest dflags diag =
-  suggestAddPragma dflags diag
-
 -- ---------------------------------------------------------------------
 
-suggestDisableWarning :: Diagnostic -> [PragmaEdit]
+suggestDisableWarning :: FileDiagnostic -> [PragmaEdit]
 suggestDisableWarning diagnostic
-  | Just (Just (JSON.Array attachedReasons)) <- diagnostic ^? attachedReason
+  | Just (Just (JSON.Array attachedReasons)) <- diagnostic ^? fdLspDiagnosticL . attachedReason
     =
     [ ("Disable \"" <> w <> "\" warnings", OptGHC w)
     | JSON.String attachedReason <- Foldable.toList attachedReasons
@@ -142,10 +162,24 @@ warningBlacklist =
 
 -- ---------------------------------------------------------------------
 
+-- | Offer to add a missing Language Pragma to the top of a file.
+suggestAddPragma :: Maybe DynFlags -> FileDiagnostic -> [PragmaEdit]
+suggestAddPragma mDynflags fd= [("Add \"" <> r <> "\"", LangExt r) | r <- map (T.pack . show) $ suggestsExtension fd, r `notElem` disabled]
+  where
+    disabled
+      | Just dynFlags <- mDynflags =
+        -- GHC does not export 'OnOff', so we have to view it as string
+        mapMaybe (T.stripPrefix "Off " . printOutputable) (extensions dynFlags)
+      | otherwise =
+        -- When the module failed to parse, we don't have access to its
+        -- dynFlags. In that case, simply don't disable any pragmas.
+        []
+
 -- | Offer to add a missing Language Pragma to the top of a file.
 -- Pragmas are defined by a curated list of known pragmas, see 'possiblePragmas'.
-suggestAddPragma :: Maybe DynFlags -> Diagnostic -> [PragmaEdit]
-suggestAddPragma mDynflags Diagnostic {_message, _source}
+-- Kept for compatibility with ghc9.6 - it is missing some structured diagnostics
+suggestAddPragma96 :: Maybe DynFlags -> Diagnostic -> [PragmaEdit]
+suggestAddPragma96 mDynflags Diagnostic {_message, _source}
     | _source == Just sourceTypecheck || _source == Just sourceParser = genPragma _message
   where
     genPragma target =
@@ -158,7 +192,7 @@ suggestAddPragma mDynflags Diagnostic {_message, _source}
         -- When the module failed to parse, we don't have access to its
         -- dynFlags. In that case, simply don't disable any pragmas.
         []
-suggestAddPragma _ _ = []
+suggestAddPragma96 _ _ = []
 
 -- | Find all Pragmas are an infix of the search term.
 findPragma :: T.Text -> [T.Text]
@@ -178,6 +212,20 @@ findPragma str = concatMap check possiblePragmas
        , "Strict" /= name
        ]
 
+suggestsExtension :: FileDiagnostic -> [Extension]
+suggestsExtension message = case   message ^? fdStructuredMessageL . _SomeStructuredMessage . msgEnvelopeErrorL of
+    Just s -> concat $ map (\case
+      SuggestExtension s -> ghcHintSuggestsExtension s
+      _ -> []) (diagnosticHints s)
+    _          -> []
+
+ghcHintSuggestsExtension :: LanguageExtensionHint -> [Extension]
+ghcHintSuggestsExtension (SuggestSingleExtension _ ext)    = [ext]
+ghcHintSuggestsExtension (SuggestAnyExtension _ (ext:_))   = [ext] -- ghc suggests any of those, we pick first
+ghcHintSuggestsExtension (SuggestAnyExtension _ [])        = []
+ghcHintSuggestsExtension (SuggestExtensions _ ext)         = ext
+ghcHintSuggestsExtension (SuggestExtensionInOrderTo _ ext) = [ext]
+
 -- | All language pragmas, including the No- variants
 allPragmas :: [T.Text]
 allPragmas =
diff --git a/plugins/hls-semantic-tokens-plugin/test/SemanticTokensTest.hs b/plugins/hls-semantic-tokens-plugin/test/SemanticTokensTest.hs
index a0d1648fb3..7daae0df51 100644
--- a/plugins/hls-semantic-tokens-plugin/test/SemanticTokensTest.hs
+++ b/plugins/hls-semantic-tokens-plugin/test/SemanticTokensTest.hs
@@ -90,7 +90,7 @@ docLspSemanticTokensString :: (HasCallStack) => TextDocumentIdentifier -> Sessio
 docLspSemanticTokensString doc = do
   res <- Test.getSemanticTokens doc
   textContent <- documentContents doc
-  let vfs = VirtualFile 0 0 (Rope.fromText textContent)
+  let vfs = VirtualFile 0 0 (Rope.fromText textContent) (Just LanguageKind_Haskell)
   case res ^? Language.LSP.Protocol.Types._L of
     Just tokens -> do
       either (error . show) pure $ recoverLspSemanticTokens vfs tokens
diff --git a/plugins/hls-signature-help-plugin/src/Ide/Plugin/SignatureHelp.hs b/plugins/hls-signature-help-plugin/src/Ide/Plugin/SignatureHelp.hs
new file mode 100644
index 0000000000..ada4d70872
--- /dev/null
+++ b/plugins/hls-signature-help-plugin/src/Ide/Plugin/SignatureHelp.hs
@@ -0,0 +1,345 @@
+{-# LANGUAGE DataKinds                #-}
+{-# LANGUAGE DisambiguateRecordFields #-}
+{-# LANGUAGE GADTs                    #-}
+
+module Ide.Plugin.SignatureHelp (descriptor) where
+
+import           Control.Arrow                        ((>>>))
+import           Control.Monad.Trans.Except           (ExceptT (ExceptT))
+import           Data.Bifunctor                       (bimap)
+import           Data.Function                        ((&))
+import           Data.IntMap                          (IntMap)
+import qualified Data.IntMap                          as IntMap
+import qualified Data.Map.Strict                      as M
+import qualified Data.Set                             as S
+import           Data.Text                            (Text)
+import qualified Data.Text                            as T
+import           Development.IDE                      (DocAndTyThingMap (DKMap),
+                                                       GetDocMap (GetDocMap),
+                                                       GetHieAst (GetHieAst),
+                                                       HieAstResult (HAR, hieAst, hieKind),
+                                                       HieKind (..),
+                                                       IdeState (shakeExtras),
+                                                       Pretty (pretty),
+                                                       Recorder, WithPriority,
+                                                       printOutputableOneLine,
+                                                       useWithStaleFast)
+import           Development.IDE.Core.PluginUtils     (runIdeActionE,
+                                                       useWithStaleFastE)
+import           Development.IDE.Core.PositionMapping (fromCurrentPosition)
+import           Development.IDE.GHC.Compat           (FastStringCompat, Name,
+                                                       RealSrcSpan,
+                                                       getSourceNodeIds,
+                                                       isAnnotationInNodeInfo,
+                                                       mkRealSrcLoc,
+                                                       mkRealSrcSpan, ppr,
+                                                       sourceNodeInfo)
+import           Development.IDE.GHC.Compat.Util      (LexicalFastString (LexicalFastString))
+import           Development.IDE.Spans.Common         (ArgDocMap, DocMap,
+                                                       SpanDoc (..),
+                                                       SpanDocUris (SpanDocUris),
+                                                       spanDocToMarkdown)
+import           GHC.Core.Map.Type                    (deBruijnize)
+import           GHC.Core.Type                        (FunTyFlag (FTF_T_T),
+                                                       Type, dropForAlls,
+                                                       splitFunTy_maybe)
+import           GHC.Data.Maybe                       (rightToMaybe)
+import           GHC.Iface.Ext.Types                  (ContextInfo (Use),
+                                                       HieAST (nodeChildren, nodeSpan),
+                                                       HieASTs (getAsts),
+                                                       IdentifierDetails (identInfo, identType),
+                                                       nodeType)
+import           GHC.Iface.Ext.Utils                  (smallestContainingSatisfying)
+import           GHC.Types.Name.Env                   (lookupNameEnv)
+import           GHC.Types.SrcLoc                     (isRealSubspanOf)
+import           Ide.Plugin.Error                     (getNormalizedFilePathE)
+import           Ide.Types                            (PluginDescriptor (pluginHandlers),
+                                                       PluginId,
+                                                       PluginMethodHandler,
+                                                       defaultPluginDescriptor,
+                                                       mkPluginHandler)
+import           Language.LSP.Protocol.Message        (Method (Method_TextDocumentSignatureHelp),
+                                                       SMethod (SMethod_TextDocumentSignatureHelp))
+import           Language.LSP.Protocol.Types          (MarkupContent (MarkupContent),
+                                                       MarkupKind (MarkupKind_Markdown),
+                                                       Null (Null),
+                                                       ParameterInformation (ParameterInformation),
+                                                       Position (Position),
+                                                       SignatureHelp (..),
+                                                       SignatureHelpContext (..),
+                                                       SignatureHelpParams (SignatureHelpParams),
+                                                       SignatureInformation (..),
+                                                       TextDocumentIdentifier (TextDocumentIdentifier),
+                                                       UInt,
+                                                       type (|?) (InL, InR))
+
+data Log
+
+instance Pretty Log where
+  pretty = \case {}
+
+descriptor :: Recorder (WithPriority Log) -> PluginId -> PluginDescriptor IdeState
+descriptor _recorder pluginId =
+  (defaultPluginDescriptor pluginId "Provides signature help of something callable")
+    { Ide.Types.pluginHandlers = mkPluginHandler SMethod_TextDocumentSignatureHelp signatureHelpProvider
+    }
+
+{- Note [Stale Results in Signature Help]
+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Stale results work well when users are reading code.
+
+When we add support for writing code, such as automatically triggering signature
+help when a space char is inserted, we probably have to use up-to-date results.
+-}
+
+{-
+Here is a brief description of the algorithm of finding relevant bits from HIE AST
+1. let 'hsAppNode' = the smallest 'HsApp' AST node which contains the cursor postion
+   See 'extractInfoFromSmallestContainingFunctionApplicationAst'
+2. let 'functionNode' = the left-most node of 'hsAppNode'
+   See 'getLeftMostNode'
+3. try to get 'functionName' and 'functionTypes' from 'functionNode'
+   We get 'Nothing' when we cannot get that info
+   See 'getNodeNameAndTypes'
+4. count 'parameterIndex' by traversing the 'hsAppNode' subtree from its root to the cursor position
+   We get 'Nothing' when either the cursor position is at 'functionNode'
+   or we encounter some AST node we do not yet know how to continue our traversal
+   See 'getParameterIndex'
+-}
+signatureHelpProvider :: PluginMethodHandler IdeState Method_TextDocumentSignatureHelp
+signatureHelpProvider ideState _pluginId (SignatureHelpParams (TextDocumentIdentifier uri) position _mProgreeToken mSignatureHelpContext) = do
+  nfp <- getNormalizedFilePathE uri
+  results <- runIdeActionE "signatureHelp.ast" (shakeExtras ideState) $ do
+    -- see Note [Stale Results in Signature Help]
+    (HAR {hieAst, hieKind}, positionMapping) <- useWithStaleFastE GetHieAst nfp
+    case fromCurrentPosition positionMapping position of
+      Nothing -> pure []
+      Just oldPosition -> do
+        pure $
+          extractInfoFromSmallestContainingFunctionApplicationAst
+            oldPosition
+            hieAst
+            ( \span hieAst -> do
+                let functionNode = getLeftMostNode hieAst
+                (functionName, functionTypes) <- getNodeNameAndTypes hieKind functionNode
+                parameterIndex <- getParameterIndex span hieAst
+                Just (functionName, functionTypes, parameterIndex)
+            )
+  (docMap, argDocMap) <- runIdeActionE "signatureHelp.docMap" (shakeExtras ideState) $ do
+    -- see Note [Stale Results in Signature Help]
+    mResult <- ExceptT $ Right <$> useWithStaleFast GetDocMap nfp
+    case mResult of
+      Just (DKMap docMap _tyThingMap argDocMap, _positionMapping) -> pure (docMap, argDocMap)
+      Nothing -> pure (mempty, mempty)
+  case results of
+    [(_functionName, [], _parameterIndex)] -> pure $ InR Null
+    [(functionName, functionTypes, parameterIndex)] ->
+      pure $ InL $ mkSignatureHelp mSignatureHelpContext docMap argDocMap (fromIntegral parameterIndex - 1) functionName functionTypes
+    _ -> pure $ InR Null
+
+mkSignatureHelp :: Maybe SignatureHelpContext -> DocMap -> ArgDocMap -> UInt -> Name -> [Type] -> SignatureHelp
+mkSignatureHelp mSignatureHelpContext docMap argDocMap parameterIndex functionName functionTypes =
+  SignatureHelp
+    { _signatures = mkSignatureInformation docMap argDocMap parameterIndex functionName <$> functionTypes,
+      _activeSignature = activeSignature,
+      _activeParameter = Just $ InL parameterIndex
+    }
+  where
+    activeSignature = case mSignatureHelpContext of
+      Just
+        ( SignatureHelpContext
+            { _triggerKind,
+              _triggerCharacter,
+              _isRetrigger = True,
+              _activeSignatureHelp = Just (SignatureHelp _signatures oldActivateSignature _activeParameter)
+            }
+          ) -> oldActivateSignature
+      _ -> Just 0
+
+mkSignatureInformation :: DocMap -> ArgDocMap -> UInt -> Name -> Type -> SignatureInformation
+mkSignatureInformation docMap argDocMap parameterIndex functionName functionType =
+  let functionNameLabelPrefix = printOutputableOneLine (ppr functionName) <> " :: "
+      mFunctionDoc = case lookupNameEnv docMap functionName of
+        Nothing      -> Nothing
+        Just spanDoc -> Just $ InR $ mkMarkdownDoc spanDoc
+      thisArgDocMap = case lookupNameEnv argDocMap functionName of
+        Nothing             -> mempty
+        Just thisArgDocMap' -> thisArgDocMap'
+   in SignatureInformation
+        { -- Server-side line wrapping may be better since more context is available.
+          -- However, server-side line wrapping may make it harder to calculate
+          -- parameter ranges.  In addition, some clients, such as vscode, ignore
+          -- server-side line wrapping and instead does client-side line wrapping.
+          -- So we choose not to do server-side line wrapping.
+          _label = functionNameLabelPrefix <> printOutputableOneLine functionType,
+          _documentation = mFunctionDoc,
+          _parameters = Just $ mkParameterInformations thisArgDocMap (fromIntegral $ T.length functionNameLabelPrefix) functionType,
+          _activeParameter = Just $ InL parameterIndex
+        }
+
+mkParameterInformations :: IntMap SpanDoc -> UInt -> Type -> [ParameterInformation]
+mkParameterInformations thisArgDocMap offset functionType =
+  [ ParameterInformation (InR range) mParameterDoc
+    | (parameterIndex, range) <- zip [0 ..] (bimap (+ offset) (+ offset) <$> findParameterRanges functionType),
+      let mParameterDoc = case IntMap.lookup parameterIndex thisArgDocMap of
+            Nothing      -> Nothing
+            Just spanDoc -> Just $ InR $ mkMarkdownDoc $ removeUris spanDoc
+  ]
+  where
+    -- we already show uris in the function doc, no need to duplicate them in the parameter doc
+    removeUris (SpanDocString docs _uris) = SpanDocString docs emptyUris
+    removeUris (SpanDocText docs _uris)   = SpanDocText docs emptyUris
+
+    emptyUris = SpanDocUris Nothing Nothing
+
+mkMarkdownDoc :: SpanDoc -> MarkupContent
+mkMarkdownDoc = spanDocToMarkdown >>> T.unlines >>> MarkupContent MarkupKind_Markdown
+
+findParameterRanges :: Type -> [(UInt, UInt)]
+findParameterRanges functionType =
+  let functionTypeString = printOutputableOneLine functionType
+      functionTypeStringLength = fromIntegral $ T.length functionTypeString
+      splitFunctionTypes = filter notTypeConstraint $ splitFunTysIgnoringForAll functionType
+      splitFunctionTypeStrings = printOutputableOneLine . fst <$> splitFunctionTypes
+      -- reverse to avoid matching "a" of "forall a" in "forall a. a -> a"
+      reversedRanges =
+        drop 1 $ -- do not need the range of the result (last) type
+          findParameterStringRanges
+            0
+            (T.reverse functionTypeString)
+            (T.reverse <$> reverse splitFunctionTypeStrings)
+   in reverse $ modifyRange functionTypeStringLength <$> reversedRanges
+  where
+    modifyRange functionTypeStringLength (start, end) =
+      (functionTypeStringLength - end, functionTypeStringLength - start)
+
+{-
+The implemented method uses both structured type and unstructured type string.
+It provides good enough results and is easier to implement than alternative
+method 1 or 2.
+
+Alternative method 1: use only structured type
+This method is hard to implement because we need to duplicate some logic of 'ppr' for 'Type'.
+Some tricky cases are as follows:
+- 'Eq a => Num b -> c' is shown as '(Eq a, Numb) => c'
+- 'forall' can appear anywhere in a type when RankNTypes is enabled
+  f :: forall a. Maybe a -> forall b. (a, b) -> b
+- '=>' can appear anywhere in a type
+  g :: forall a b. Eq a => a -> Num b => b -> b
+- ppr the first parameter type of '(a -> b) -> a -> b' is 'a -> b' (no parentheses)
+- 'forall' is not always shown
+
+Alternative method 2: use only unstructured type string
+This method is hard to implement because we need to parse the type string.
+Some tricky cases are as follows:
+- h :: forall a (m :: Type -> Type). Monad m => a -> m a
+-}
+findParameterStringRanges :: UInt -> Text -> [Text] -> [(UInt, UInt)]
+findParameterStringRanges _totalPrefixLength _functionTypeString [] = []
+findParameterStringRanges totalPrefixLength functionTypeString (parameterTypeString : restParameterTypeStrings) =
+  let (prefix, match) = T.breakOn parameterTypeString functionTypeString
+      prefixLength = fromIntegral $ T.length prefix
+      parameterTypeStringLength = fromIntegral $ T.length parameterTypeString
+      start = totalPrefixLength + prefixLength
+   in (start, start + parameterTypeStringLength)
+        : findParameterStringRanges
+          (totalPrefixLength + prefixLength + parameterTypeStringLength)
+          (T.drop (fromIntegral parameterTypeStringLength) match)
+          restParameterTypeStrings
+
+-- similar to 'splitFunTys' but
+--   1) the result (last) type is included and
+--   2) toplevel foralls are ignored
+splitFunTysIgnoringForAll :: Type -> [(Type, Maybe FunTyFlag)]
+splitFunTysIgnoringForAll ty = case ty & dropForAlls & splitFunTy_maybe of
+  Just (funTyFlag, _mult, parameterType, resultType) ->
+    (parameterType, Just funTyFlag) : splitFunTysIgnoringForAll resultType
+  Nothing -> [(ty, Nothing)]
+
+notTypeConstraint :: (Type, Maybe FunTyFlag) -> Bool
+notTypeConstraint (_type, Just FTF_T_T) = True
+notTypeConstraint (_type, Nothing)      = True
+notTypeConstraint _                     = False
+
+extractInfoFromSmallestContainingFunctionApplicationAst ::
+  Position -> HieASTs a -> (RealSrcSpan -> HieAST a -> Maybe b) -> [b]
+extractInfoFromSmallestContainingFunctionApplicationAst position hieAsts extractInfo =
+  M.elems $ flip M.mapMaybeWithKey (getAsts hieAsts) $ \hiePath hieAst ->
+    smallestContainingSatisfying (positionToSpan hiePath position) (nodeHasAnnotation ("HsApp", "HsExpr")) hieAst
+      >>= extractInfo (positionToSpan hiePath position)
+  where
+    positionToSpan hiePath position =
+      let loc = mkLoc hiePath position in mkRealSrcSpan loc loc
+    mkLoc (LexicalFastString hiePath) (Position line character) =
+      mkRealSrcLoc hiePath (fromIntegral line + 1) (fromIntegral character + 1)
+
+type Annotation = (FastStringCompat, FastStringCompat)
+
+nodeHasAnnotation :: Annotation -> HieAST a -> Bool
+nodeHasAnnotation annotation hieAst = case sourceNodeInfo hieAst of
+  Nothing       -> False
+  Just nodeInfo -> isAnnotationInNodeInfo annotation nodeInfo
+
+getLeftMostNode :: HieAST a -> HieAST a
+getLeftMostNode thisNode =
+  case nodeChildren thisNode of
+    []            -> thisNode
+    leftChild : _ -> getLeftMostNode leftChild
+
+getNodeNameAndTypes :: HieKind a -> HieAST a -> Maybe (Name, [Type])
+getNodeNameAndTypes hieKind hieAst =
+  if nodeHasAnnotation ("HsVar", "HsExpr") hieAst
+    then case hieAst & getSourceNodeIds & M.filter isUse & M.assocs of
+      [(identifier, identifierDetails)] ->
+        case extractName identifier of
+          Nothing -> Nothing
+          Just name ->
+            let mTypeOfName = identType identifierDetails
+                typesOfNode = case sourceNodeInfo hieAst of
+                  Nothing       -> []
+                  Just nodeInfo -> nodeType nodeInfo
+                allTypes = case mTypeOfName of
+                  Nothing -> typesOfNode
+                  -- (the last?) one type of 'typesOfNode' may (always?) be the same as 'typeOfName'
+                  -- To avoid generating two identical signature helps, we do a filtering here
+                  -- This is similar to 'dropEnd1' in Development.IDE.Spans.AtPoint.atPoint
+                  -- TODO perhaps extract a common function
+                  Just typeOfName -> typeOfName : filter (isDifferentType typeOfName) typesOfNode
+             in Just (name, filterCoreTypes allTypes)
+      [] -> Nothing
+      _ -> Nothing -- seems impossible
+    else Nothing
+  where
+    extractName = rightToMaybe
+
+    isDifferentType type1 type2 = case hieKind of
+      HieFresh       -> deBruijnize type1 /= deBruijnize type2
+      HieFromDisk {} -> type1 /= type2
+
+    filterCoreTypes types = case hieKind of
+      HieFresh       -> types
+      -- ignore this case since this only happens before we finish startup
+      HieFromDisk {} -> []
+
+isUse :: IdentifierDetails a -> Bool
+isUse = identInfo >>> S.member Use
+
+-- Just 1 means the first parameter
+getParameterIndex :: RealSrcSpan -> HieAST a -> Maybe Integer
+getParameterIndex span hieAst
+  | nodeHasAnnotation ("HsApp", "HsExpr") hieAst =
+      case nodeChildren hieAst of
+        [leftChild, _] ->
+          if span `isRealSubspanOf` nodeSpan leftChild
+            then Nothing
+            else getParameterIndex span leftChild >>= \parameterIndex -> Just (parameterIndex + 1)
+        _ -> Nothing -- impossible
+  | nodeHasAnnotation ("HsAppType", "HsExpr") hieAst =
+      case nodeChildren hieAst of
+        [leftChild, _] -> getParameterIndex span leftChild
+        _              -> Nothing -- impossible
+  | otherwise =
+      case nodeChildren hieAst of
+        []      -> Just 0 -- the function is found
+        [child] -> getParameterIndex span child -- ignore irrelevant nodes
+        _       -> Nothing
diff --git a/plugins/hls-signature-help-plugin/test/Main.hs b/plugins/hls-signature-help-plugin/test/Main.hs
new file mode 100644
index 0000000000..f22fbaf400
--- /dev/null
+++ b/plugins/hls-signature-help-plugin/test/Main.hs
@@ -0,0 +1,515 @@
+{-# LANGUAGE DataKinds   #-}
+{-# LANGUAGE QuasiQuotes #-}
+
+import           Control.Arrow                            ((>>>))
+import           Control.Exception                        (throw)
+import           Control.Lens                             ((^.))
+import           Data.Maybe                               (fromJust)
+import           Data.Text                                (Text)
+import qualified Data.Text                                as T
+import           Development.IDE.Plugin.Completions.Types (PosPrefixInfo (PosPrefixInfo))
+import           Ide.Plugin.SignatureHelp                 (descriptor)
+import qualified Language.LSP.Protocol.Lens               as L
+import           Test.Hls                                 hiding
+                                                          (getSignatureHelp)
+import           Test.Hls.FileSystem                      (VirtualFileTree,
+                                                           directCradle, file,
+                                                           mkVirtualFileTree,
+                                                           text)
+
+main :: IO ()
+main =
+  defaultTestRunner $
+    testGroup
+      "signatureHelp"
+      [ mkTest
+          "1 parameter"
+          [__i|
+            f :: Int -> Int
+            f = _
+            x = f 1
+            ^^^^^^^^
+          |]
+          [ Nothing,
+            Nothing,
+            Nothing,
+            Nothing,
+            Nothing,
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "2 parameters"
+          [__i|
+            f :: Int -> Int -> Int
+            f = _
+            x = f 1 2
+                ^ ^^^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1))
+          ],
+        mkTest
+          "3 parameters"
+          [__i|
+            f :: Int -> Int -> Int -> Int
+            f = _
+            x = f 1 2 3
+                ^ ^ ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing, ParameterInformation (InR (19, 22)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing, ParameterInformation (InR (19, 22)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing, ParameterInformation (InR (19, 22)) Nothing]) (Just (InL 2))] (Just 0) (Just (InL 2))
+          ],
+        mkTest
+          "parentheses"
+          [__i|
+            f :: Int -> Int -> Int
+            f = _
+            x = (f 1) 2
+                ^^ ^^^^
+          |]
+          [ Nothing,
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1))
+          ],
+        mkTest
+          "newline"
+          [__i|
+            f :: Int -> Int -> Int
+            f = _
+            x =
+              (
+              ^
+              f
+              ^
+              1
+              ^
+              )
+              ^
+              2
+              ^
+
+              ^
+          |]
+          [ Nothing,
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1)),
+            Nothing
+          ],
+        mkTest
+          "nested"
+          [__i|
+            f :: Int -> Int -> Int
+            f = _
+            g :: Int -> Int
+            g = _
+            x = f (g 1) 2
+                ^^^^ ^^^^
+          |]
+          [ Nothing,
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "g :: Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "g :: Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1))
+          ],
+        mkTest
+          "higher-order function"
+          [__i|
+            f :: (Int -> Int) -> Int -> Int
+            f = _
+            x = f (+ 1) 2
+                ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: (Int -> Int) -> Int -> Int" Nothing (Just [ParameterInformation (InR (6, 16)) Nothing, ParameterInformation (InR (21, 24)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "type constraint"
+          [__i|
+            f :: (Num a) => a -> a -> a
+            f = _
+            x = f 1 2
+                ^ ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Num a => a -> a -> a" Nothing (Just [ParameterInformation (InR (24, 25)) Nothing, ParameterInformation (InR (29, 30)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (16, 23)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Num a => a -> a -> a" Nothing (Just [ParameterInformation (InR (24, 25)) Nothing, ParameterInformation (InR (29, 30)) Nothing]) (Just (InL 1)), SignatureInformation "f :: Integer -> Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (16, 23)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1))
+          ],
+        mkTest
+          "type constraint with kind signatures"
+          [__i|
+            x :: IO Bool
+            x = pure True
+                 ^   ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "pure :: forall (f :: Type -> Type) a. Applicative f => a -> f a" (Just $ InR $ MarkupContent MarkupKind_Markdown "Lift a value") (Just [ParameterInformation (InR (55, 56)) Nothing]) (Just (InL 0)), SignatureInformation "pure :: Bool -> IO Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "Lift a value") (Just [ParameterInformation (InR (8, 12)) Nothing]) (Just (InL 0)), SignatureInformation "pure :: forall a. a -> IO a" (Just $ InR $ MarkupContent MarkupKind_Markdown "Lift a value") (Just [ParameterInformation (InR (18, 19)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "2 type constraints"
+          [__i|
+            f :: forall a. (Eq a, Num a) => a -> a -> a
+            f = _
+            x = f True
+                ^   ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. (Eq a, Num a) => a -> a -> a" Nothing (Just [ParameterInformation (InR (32, 33)) Nothing, ParameterInformation (InR (37, 38)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Bool -> Bool -> Bool" Nothing (Just [ParameterInformation (InR (5, 9)) Nothing, ParameterInformation (InR (13, 17)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "dynamic function"
+          [__i|
+            f :: Int -> Int -> Int
+            f = _
+            g :: Int -> Int -> Int
+            g = _
+            x = (if _ then f else g) 1 2
+                ^^ ^^^ ^  ^^^ ^  ^^^^^^^^
+          |]
+          (replicate 18 Nothing),
+        mkTest
+          "very long type"
+          [__i|
+            f :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int
+            f = _
+            x = f 1
+                ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int" Nothing (Just [ParameterInformation (InR (5, 8)) Nothing, ParameterInformation (InR (12, 15)) Nothing, ParameterInformation (InR (19, 22)) Nothing, ParameterInformation (InR (26, 29)) Nothing, ParameterInformation (InR (33, 36)) Nothing, ParameterInformation (InR (40, 43)) Nothing, ParameterInformation (InR (47, 50)) Nothing, ParameterInformation (InR (54, 57)) Nothing, ParameterInformation (InR (61, 64)) Nothing, ParameterInformation (InR (68, 71)) Nothing, ParameterInformation (InR (75, 78)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "very long type with type constraint"
+          [__i|
+            f :: Num abcdefghijklmn => abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn
+            f = _
+            x = f 1
+                ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall abcdefghijklmn. Num abcdefghijklmn => abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn -> abcdefghijklmn" Nothing (Just [ParameterInformation (InR (50, 64)) Nothing, ParameterInformation (InR (68, 82)) Nothing, ParameterInformation (InR (86, 100)) Nothing, ParameterInformation (InR (104, 118)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Integer -> Integer -> Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (16, 23)) Nothing, ParameterInformation (InR (27, 34)) Nothing, ParameterInformation (InR (38, 45)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        -- TODO fix bug of wrong parameter range in the function type string
+        -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
+        mkTestExpectFail
+          "middle =>"
+          [__i|
+            f :: Eq a => a -> Num b => b -> b
+            f = _
+            x = f 1 True
+                ^ ^ ^
+            y = f True
+                  ^
+            z = f 1
+                  ^
+          |]
+          ( BrokenIdeal
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Num Bool => Bool -> Bool" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (28, 32)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 1)), SignatureInformation "f :: Integer -> Num Bool => Bool -> Bool" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (28, 32)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Bool -> Num Integer => Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 9)) Nothing, ParameterInformation (InR (28, 35)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Num Integer => Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (31, 38)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          )
+          ( BrokenCurrent
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Num Bool => Bool -> Bool" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (28, 32)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 1)), SignatureInformation "f :: Integer -> Num Bool => Bool -> Bool" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (28, 32)) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Bool -> Num Integer => Integer -> Integer" Nothing (Just [ParameterInformation (InR (5, 9)) Nothing, ParameterInformation (InR (28, 35)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> Num b => b -> b" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (39, 40)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> Num Integer => Integer -> Integer" Nothing (Just [ParameterInformation (InR (20, 27)) Nothing, ParameterInformation (InR (31, 38)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          ),
+        mkTest
+          "=> in parameter"
+          [__i|
+            f :: Eq a => a -> (Num b => b -> b) -> a
+            f = _
+            x = f 1
+                ^ ^
+            y = f 1 negate
+                  ^ ^
+          |]
+          ( let typ =
+                  if ghcVersion <= GHC98
+                    then "f :: Integer -> (Num Any => Any -> Any) -> Integer"
+                    else "f :: Integer -> (Num (ZonkAny 0) => ZonkAny 0 -> ZonkAny 0) -> Integer"
+                range = if ghcVersion <= GHC98 then (17, 38) else (17, 58)
+             in [ Nothing,
+                  Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> (Num b => b -> b) -> a" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (31, 46)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> (Num b => b -> b) -> Integer" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (17, 32)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                  Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> (Num b => b -> b) -> a" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (31, 46)) Nothing]) (Just (InL 0)), SignatureInformation typ Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR range) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+                  Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. Eq a => a -> (Num b => b -> b) -> a" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (31, 46)) Nothing]) (Just (InL 1)), SignatureInformation typ Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR range) Nothing]) (Just (InL 1))] (Just 0) (Just (InL 1))
+                ]
+          ),
+        mkTest
+          "RankNTypes(forall in middle)"
+          [__i|
+            f :: Maybe a -> forall b. (a, b) -> b
+            f = _
+            x1 = f Nothing
+                 ^ ^
+            x2 = f (Just True)
+                   ^
+            x3 = f Nothing (1, True)
+                   ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (15, 22)) Nothing, ParameterInformation (InR (36, 42)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 32)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (15, 22)) Nothing, ParameterInformation (InR (36, 42)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Maybe Bool -> forall b. (Bool, b) -> b" Nothing (Just [ParameterInformation (InR (5, 15)) Nothing, ParameterInformation (InR (29, 38)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. Maybe a -> forall b. (a, b) -> b" Nothing (Just [ParameterInformation (InR (15, 22)) Nothing, ParameterInformation (InR (36, 42)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Maybe Integer -> forall b. (Integer, b) -> b" Nothing (Just [ParameterInformation (InR (5, 18)) Nothing, ParameterInformation (InR (32, 44)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        -- TODO fix bug of wrong parameter range in the function type string
+        -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
+        mkTestExpectFail
+          "RankNTypes(forall in middle), another"
+          [__i|
+            f :: l -> forall a. a -> a
+            f = _
+            x = f 1
+                ^ ^
+          |]
+          ( BrokenIdeal
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall l. l -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (15, 16)) Nothing, ParameterInformation (InR (30, 31)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 27)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          )
+          ( BrokenCurrent
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall l. l -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (25, 26)) Nothing, ParameterInformation (InR (30, 31)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 27)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          ),
+        -- TODO fix bug of wrong parameter range in the function type string
+        -- https://github.com/haskell/haskell-language-server/pull/4626#discussion_r2261133076
+        mkTestExpectFail
+          "RankNTypes(forall in middle), again"
+          [__i|
+            f :: a -> forall a. a -> a
+            f = _
+            x = f 1
+                ^ ^
+          |]
+          ( BrokenIdeal
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. a -> forall a1. a1 -> a1" Nothing (Just [ParameterInformation (InR (15, 16)) Nothing, ParameterInformation (InR (31, 33)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 27)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          )
+          ( BrokenCurrent
+              [ Nothing,
+                Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a. a -> forall a1. a1 -> a1" Nothing (Just [ParameterInformation (InR (27, 28)) Nothing, ParameterInformation (InR (31, 32)) Nothing]) (Just (InL 0)), SignatureInformation "f :: Integer -> forall a. a -> a" Nothing (Just [ParameterInformation (InR (5, 12)) Nothing, ParameterInformation (InR (26, 27)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+              ]
+          ),
+        mkTest
+          "LinearTypes"
+          [__i|
+            {-\# LANGUAGE LinearTypes \#-}
+            f :: (a -> b) %1 -> a -> b
+            f = _
+            x1 = f negate
+                 ^ ^
+            x2 = f _ 1
+                   ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. (a -> b) %1 -> a -> b" Nothing (Just [ParameterInformation (InR (18, 24)) Nothing, ParameterInformation (InR (32, 33)) Nothing]) (Just (InL 0)), SignatureInformation "f :: (Integer -> Integer) %1 -> Integer -> Integer" Nothing (Just [ParameterInformation (InR (6, 24)) Nothing, ParameterInformation (InR (32, 39)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0)),
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b. (a -> b) %1 -> a -> b" Nothing (Just [ParameterInformation (InR (18, 24)) Nothing, ParameterInformation (InR (32, 33)) Nothing]) (Just (InL 0)), SignatureInformation "f :: (Integer -> b) %1 -> Integer -> b" Nothing (Just [ParameterInformation (InR (6, 18)) Nothing, ParameterInformation (InR (26, 33)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "function documentation"
+          [__i|
+            -- |The 'f' function does something to a bool value.
+            f :: Bool -> Bool
+            f = _
+            x = f True
+                ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Bool -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "The  `f`  function does something to a bool value") (Just [ParameterInformation (InR (5, 9)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "function and parameters documentation"
+          [__i|
+            -- |Doc for function 'f'.
+            f ::
+              -- | The first 'Bool' parameter
+              Bool ->
+              -- | The second 'Int' parameter
+              Int ->
+              -- | The return value
+              Bool
+            f = _
+            x = f True 1
+                ^ ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: Bool -> Int -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "Doc for function  `f`") (Just [ParameterInformation (InR (5, 9)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The first  `Bool`  parameter"), ParameterInformation (InR (13, 16)) (Just $ InR $ MarkupContent MarkupKind_Markdown "The second  `Int`  parameter")]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "imported function with no documentation"
+          [__i|
+            x = even 1
+                ^    ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "even :: forall a. Integral a => a -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "") (Just [ParameterInformation (InR (32, 33)) Nothing]) (Just (InL 0)), SignatureInformation "even :: Integer -> Bool" (Just $ InR $ MarkupContent MarkupKind_Markdown "") (Just [ParameterInformation (InR (8, 15)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "imported function with parameter documentation"
+          [__i|
+            import Language.Haskell.TH.Lib (mkBytes)
+            x = mkBytes _
+                ^       ^
+          |]
+          [ Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "mkBytes :: ForeignPtr Word8 -> Word -> Word -> Bytes" (Just $ InR $ MarkupContent MarkupKind_Markdown "Create a Bytes datatype representing raw bytes to be embedded into the") (Just [ParameterInformation (InR (11, 27)) (Just $ InR $ MarkupContent MarkupKind_Markdown "Pointer to the data"), ParameterInformation (InR (31, 35)) (Just $ InR $ MarkupContent MarkupKind_Markdown "Offset from the pointer"), ParameterInformation (InR (39, 43)) (Just $ InR $ MarkupContent MarkupKind_Markdown "Number of bytes")]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ],
+        mkTest
+          "TypeApplications"
+          [__i|
+            f :: a -> b -> c
+            f = _
+            x = f @Int @_ 1 True
+                ^  ^    ^ ^
+          |]
+          [ Nothing,
+            Nothing,
+            Nothing,
+            Just $ SimilarSignatureHelp $ SignatureHelp [SignatureInformation "f :: forall a b c. a -> b -> c" Nothing (Just [ParameterInformation (InR (19, 20)) Nothing, ParameterInformation (InR (24, 25)) Nothing]) (Just (InL 0))] (Just 0) (Just (InL 0))
+          ]
+      ]
+
+mkTest :: TestName -> Text -> [Maybe SimilarSignatureHelp] -> TestTree
+mkTest name sourceCode expectedSignatureHelps =
+  parameterisedCursorTest
+    name
+    sourceCode
+    expectedSignatureHelps
+    getSignatureHelpFromSession
+
+mkTestExpectFail ::
+  TestName ->
+  Text ->
+  ExpectBroken 'Ideal [Maybe SimilarSignatureHelp] ->
+  ExpectBroken 'Current [Maybe SimilarSignatureHelp] ->
+  TestTree
+mkTestExpectFail name sourceCode _idealSignatureHelps = unCurrent >>> mkTest name sourceCode
+
+getSignatureHelpFromSession :: Text -> PosPrefixInfo -> IO (Maybe SimilarSignatureHelp)
+getSignatureHelpFromSession sourceCode (PosPrefixInfo _ _ _ position) =
+  let fileName = "A.hs"
+      plugin = mkPluginTestDescriptor descriptor "signatureHelp"
+      virtualFileTree = mkVirtualFileTreeWithSingleFile fileName sourceCode
+   in runSessionWithServerInTmpDir def plugin virtualFileTree $ do
+        doc <- openDoc fileName "haskell"
+        (fmap . fmap) SimilarSignatureHelp (getSignatureHelp doc position)
+
+mkVirtualFileTreeWithSingleFile :: FilePath -> Text -> VirtualFileTree
+mkVirtualFileTreeWithSingleFile fileName sourceCode =
+  let testDataDir = "/not-used-dir"
+   in mkVirtualFileTree
+        testDataDir
+        [ directCradle [T.pack fileName],
+          file fileName (text sourceCode)
+        ]
+
+newtype SimilarSignatureHelp = SimilarSignatureHelp SignatureHelp
+  deriving newtype (Show)
+
+-- custom Eq to ignore some details, such as added doc string
+-- not symmetry
+instance Eq SimilarSignatureHelp where
+  SimilarSignatureHelp
+    actualSignatureHelp@( SignatureHelp
+                            actualSignatureInformations
+                            actualActiveSignature
+                            actualActiveParameter
+                          )
+    == SimilarSignatureHelp
+         expectedSignatureHelp@( SignatureHelp
+                                   expectedSignatureInformations
+                                   expectedActiveSignature
+                                   expectedActiveParameter
+                                 )
+      | actualSignatureHelp == expectedSignatureHelp = True
+      | actualActiveSignature == expectedActiveSignature
+          && actualActiveParameter == expectedActiveParameter =
+          actualSignatureInformations ~= expectedSignatureInformations
+      | otherwise = False
+
+class IsSimilar a where
+  (~=) :: a -> a -> Bool
+
+instance IsSimilar SignatureInformation where
+  actualSignatureInformation@( SignatureInformation
+                                 actualLabel
+                                 actualDocumentation
+                                 actualParameters
+                                 actualActiveParameter
+                               )
+    ~= expectedSignatureInformation@( SignatureInformation
+                                        expectedLabel
+                                        expectedDocumentation
+                                        expectedParameters
+                                        expectedActiveParameter
+                                      )
+      | actualSignatureInformation == expectedSignatureInformation = True
+      | actualLabel == expectedLabel && actualActiveParameter == expectedActiveParameter =
+          actualDocumentation ~= expectedDocumentation
+            && actualParameters ~= expectedParameters
+      | otherwise = False
+
+instance IsSimilar ParameterInformation where
+  actualParameterInformation@(ParameterInformation actualLabel actualDocumentation)
+    ~= expectedParameterInformation@(ParameterInformation expectedLabel expectedDocumentation)
+      | actualParameterInformation == expectedParameterInformation = True
+      | actualLabel == expectedLabel = actualDocumentation ~= expectedDocumentation
+      | otherwise = False
+
+instance IsSimilar MarkupContent where
+  actualMarkupContent@(MarkupContent actualKind actualText)
+    ~= expectedMarkupContent@(MarkupContent expectedKind expectedText)
+      | actualMarkupContent == expectedMarkupContent = True
+      | actualKind == expectedKind = actualText ~= expectedText
+      | otherwise = False
+
+instance IsSimilar Text where
+  actualText ~= expectedText = expectedText `T.isInfixOf` actualText
+
+instance (IsSimilar a) => IsSimilar [a] where
+  [] ~= []             = True
+  (x : xs) ~= (y : ys) = x ~= y && xs ~= ys
+  _ ~= _               = False
+
+instance (IsSimilar a) => IsSimilar (Maybe a) where
+  Nothing ~= Nothing = True
+  Just x ~= Just y   = x ~= y
+  _ ~= _             = False
+
+instance (IsSimilar a, IsSimilar b) => IsSimilar (a |? b) where
+  InL x ~= InL y = x ~= y
+  InR x ~= InR y = x ~= y
+  _ ~= _         = False
+
+-- TODO use the one from lsp-test when we have https://github.com/haskell/lsp/pull/621
+
+-- | Returns the signature help at the specified position.
+getSignatureHelp :: TextDocumentIdentifier -> Position -> Session (Maybe SignatureHelp)
+getSignatureHelp doc pos =
+  let params = SignatureHelpParams doc pos Nothing Nothing
+   in nullToMaybe . getResponseResult <$> request SMethod_TextDocumentSignatureHelp params
+  where
+    getResponseResult rsp =
+      case rsp ^. L.result of
+        Right x  -> x
+        Left err -> throw $ UnexpectedResponseError (fromJust $ rsp ^. L.id) err
diff --git a/run_progress_test.sh b/run_progress_test.sh
new file mode 100644
index 0000000000..24101db454
--- /dev/null
+++ b/run_progress_test.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+# pattern="edit header"
+
+# test_target="func-test"
+# pattern="sends indefinite progress notifications"
+test_target="ghcide-tests"
+pattern="lower-case drive"
+# HLS_TEST_LOG_STDERR=1
+NumberOfRuns=1
+  # TASTY_PATTERN="sends indefinite progress notifications" cabal test func-test
+  # TASTY_PATTERN="notification handlers run in priority order" cabal test ghcide-tests
+
+
+cabal build $test_target
+targetBin=$(find dist-newstyle -type f -name $test_target)
+for i in {1..$NumberOfRuns}; do
+  echo "Run #$i"
+  # TASTY_PATTERN=$pattern HLS_TEST_LOG_STDERR=$HLS_TEST_LOG_STDERR HLS_TEST_HARNESS_STDERR=1 $targetBin
+  TASTY_PATTERN=$pattern HLS_TEST_HARNESS_STDERR=1 $targetBin
+done
diff --git a/src/HlsPlugins.hs b/src/HlsPlugins.hs
index 4c135fc48b..51fc196fdb 100644
--- a/src/HlsPlugins.hs
+++ b/src/HlsPlugins.hs
@@ -53,6 +53,10 @@ import qualified Ide.Plugin.Hlint                  as Hlint
 import qualified Ide.Plugin.Stan                   as Stan
 #endif
 
+#if hls_signatureHelp
+import qualified Ide.Plugin.SignatureHelp          as SignatureHelp
+#endif
+
 #if hls_moduleName
 import qualified Ide.Plugin.ModuleName             as ModuleName
 #endif
@@ -214,6 +218,9 @@ idePlugins recorder = pluginDescToIdePlugins allPlugins
 #if hls_stan
       let pId = "stan" in Stan.descriptor (pluginRecorder pId) pId :
 #endif
+#if hls_signatureHelp
+      let pId = "signatureHelp" in SignatureHelp.descriptor (pluginRecorder pId) pId:
+#endif
 #if hls_splice
       Splice.descriptor "splice" :
 #endif
@@ -249,4 +256,3 @@ idePlugins recorder = pluginDescToIdePlugins allPlugins
       let pId = "notes" in Notes.descriptor (pluginRecorder pId) pId :
 #endif
       GhcIde.descriptors (pluginRecorder "ghcide")
-
diff --git a/test/testdata/schema/ghc910/default-config.golden.json b/test/testdata/schema/ghc910/default-config.golden.json
index 3b4e687ef9..81b63dc6e4 100644
--- a/test/testdata/schema/ghc910/default-config.golden.json
+++ b/test/testdata/schema/ghc910/default-config.golden.json
@@ -150,6 +150,9 @@
             },
             "globalOn": false
         },
+        "signatureHelp": {
+            "globalOn": true
+        },
         "stan": {
             "globalOn": false
         }
diff --git a/test/testdata/schema/ghc910/vscode-extension-schema.golden.json b/test/testdata/schema/ghc910/vscode-extension-schema.golden.json
index 4ca08f296c..ba79ee22c7 100644
--- a/test/testdata/schema/ghc910/vscode-extension-schema.golden.json
+++ b/test/testdata/schema/ghc910/vscode-extension-schema.golden.json
@@ -1037,6 +1037,12 @@
         "scope": "resource",
         "type": "boolean"
     },
+    "haskell.plugin.signatureHelp.globalOn": {
+        "default": true,
+        "description": "Enables signatureHelp plugin",
+        "scope": "resource",
+        "type": "boolean"
+    },
     "haskell.plugin.stan.globalOn": {
         "default": false,
         "description": "Enables stan plugin",
diff --git a/test/testdata/schema/ghc912/default-config.golden.json b/test/testdata/schema/ghc912/default-config.golden.json
index 0dfbd39df2..598e3a4f2e 100644
--- a/test/testdata/schema/ghc912/default-config.golden.json
+++ b/test/testdata/schema/ghc912/default-config.golden.json
@@ -149,6 +149,9 @@
                 "variableToken": "variable"
             },
             "globalOn": false
+        },
+        "signatureHelp": {
+            "globalOn": true
         }
     },
     "sessionLoading": "singleComponent"
diff --git a/test/testdata/schema/ghc912/vscode-extension-schema.golden.json b/test/testdata/schema/ghc912/vscode-extension-schema.golden.json
index 77d398438e..68f1b4f800 100644
--- a/test/testdata/schema/ghc912/vscode-extension-schema.golden.json
+++ b/test/testdata/schema/ghc912/vscode-extension-schema.golden.json
@@ -1036,5 +1036,11 @@
         "description": "Enables semanticTokens plugin",
         "scope": "resource",
         "type": "boolean"
+    },
+    "haskell.plugin.signatureHelp.globalOn": {
+        "default": true,
+        "description": "Enables signatureHelp plugin",
+        "scope": "resource",
+        "type": "boolean"
     }
 }
diff --git a/test/testdata/schema/ghc96/default-config.golden.json b/test/testdata/schema/ghc96/default-config.golden.json
index 8467b451f1..efe24df3ae 100644
--- a/test/testdata/schema/ghc96/default-config.golden.json
+++ b/test/testdata/schema/ghc96/default-config.golden.json
@@ -153,6 +153,9 @@
             },
             "globalOn": false
         },
+        "signatureHelp": {
+            "globalOn": true
+        },
         "splice": {
             "globalOn": true
         },
diff --git a/test/testdata/schema/ghc96/vscode-extension-schema.golden.json b/test/testdata/schema/ghc96/vscode-extension-schema.golden.json
index 1c0b19eb27..50ed005112 100644
--- a/test/testdata/schema/ghc96/vscode-extension-schema.golden.json
+++ b/test/testdata/schema/ghc96/vscode-extension-schema.golden.json
@@ -1043,6 +1043,12 @@
         "scope": "resource",
         "type": "boolean"
     },
+    "haskell.plugin.signatureHelp.globalOn": {
+        "default": true,
+        "description": "Enables signatureHelp plugin",
+        "scope": "resource",
+        "type": "boolean"
+    },
     "haskell.plugin.splice.globalOn": {
         "default": true,
         "description": "Enables splice plugin",
diff --git a/test/testdata/schema/ghc98/default-config.golden.json b/test/testdata/schema/ghc98/default-config.golden.json
index 8467b451f1..efe24df3ae 100644
--- a/test/testdata/schema/ghc98/default-config.golden.json
+++ b/test/testdata/schema/ghc98/default-config.golden.json
@@ -153,6 +153,9 @@
             },
             "globalOn": false
         },
+        "signatureHelp": {
+            "globalOn": true
+        },
         "splice": {
             "globalOn": true
         },
diff --git a/test/testdata/schema/ghc98/vscode-extension-schema.golden.json b/test/testdata/schema/ghc98/vscode-extension-schema.golden.json
index 1c0b19eb27..50ed005112 100644
--- a/test/testdata/schema/ghc98/vscode-extension-schema.golden.json
+++ b/test/testdata/schema/ghc98/vscode-extension-schema.golden.json
@@ -1043,6 +1043,12 @@
         "scope": "resource",
         "type": "boolean"
     },
+    "haskell.plugin.signatureHelp.globalOn": {
+        "default": true,
+        "description": "Enables signatureHelp plugin",
+        "scope": "resource",
+        "type": "boolean"
+    },
     "haskell.plugin.splice.globalOn": {
         "default": true,
         "description": "Enables splice plugin",