+{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE RankNTypes #-}
module Language.Haskell.LSP.Test.Session
( Session
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.Except
+#if __GLASGOW_HASKELL__ >= 806
+import Control.Monad.Fail
+#endif
import Control.Monad.Trans.Reader (ReaderT, runReaderT)
import qualified Control.Monad.Trans.Reader as Reader (ask)
import Control.Monad.Trans.State (StateT, runStateT)
import Data.Conduit.Parser as Parser
import Data.Default
import Data.Foldable
+import Data.IORef
import Data.List
import qualified Data.Map as Map
import qualified Data.Text as T
import Data.Function
import Language.Haskell.LSP.Messages
import Language.Haskell.LSP.Types.Capabilities
-import Language.Haskell.LSP.Types hiding (error)
+import Language.Haskell.LSP.Types
+import Language.Haskell.LSP.Types.Lens hiding (error)
import Language.Haskell.LSP.VFS
import Language.Haskell.LSP.Test.Decoding
import Language.Haskell.LSP.Test.Exceptions
-- | A session representing one instance of launching and connecting to a server.
--
--- You can send and receive messages to the server within 'Session' via 'getMessage',
--- 'sendRequest' and 'sendNotification'.
---
--- @
--- runSession \"path\/to\/root\/dir\" $ do
--- docItem <- getDocItem "Desktop/simple.hs" "haskell"
--- sendNotification TextDocumentDidOpen (DidOpenTextDocumentParams docItem)
--- diagnostics <- getMessage :: Session PublishDiagnosticsNotification
--- @
+-- You can send and receive messages to the server within 'Session' via
+-- 'Language.Haskell.LSP.Test.message',
+-- 'Language.Haskell.LSP.Test.sendRequest' and
+-- 'Language.Haskell.LSP.Test.sendNotification'.
+
type Session = ParserStateReader FromServerMessage SessionState SessionContext IO
+#if __GLASGOW_HASKELL__ >= 806
+instance MonadFail Session where
+ fail s = do
+ lastMsg <- fromJust . lastReceivedMessage <$> get
+ liftIO $ throw (UnexpectedMessage s lastMsg)
+#endif
+
-- | Stuff you can configure for a 'Session'.
data SessionConfig = SessionConfig
{ messageTimeout :: Int -- ^ Maximum time to wait for a message in seconds, defaults to 60.
, logStdErr :: Bool -- ^ Redirect the server's stderr to this stdout, defaults to False.
- , logMessages :: Bool -- ^ Trace the messages sent and received to stdout, defaults to True.
+ , logMessages :: Bool -- ^ Trace the messages sent and received to stdout, defaults to False.
, logColor :: Bool -- ^ Add ANSI color to the logged messages, defaults to True.
+ , lspConfig :: Maybe Value -- ^ The initial LSP config as JSON value, defaults to Nothing.
}
-- | The configuration used in 'Language.Haskell.LSP.Test.runSession'.
defaultConfig :: SessionConfig
-defaultConfig = SessionConfig 60 False True True
+defaultConfig = SessionConfig 60 False False True Nothing
instance Default SessionConfig where
def = defaultConfig
{
curReqId :: LspId
, vfs :: VFS
- , curDiagnostics :: Map.Map Uri [Diagnostic]
+ , curDiagnostics :: Map.Map NormalizedUri [Diagnostic]
, curTimeoutId :: Int
, overridingTimeout :: Bool
-- ^ The last received message from the server.
-> Session a
-> IO a
runSessionWithHandles serverIn serverOut serverHandler config caps rootDir session = do
+ -- We use this IORef to make exception non-fatal when the server is supposed to shutdown.
+
+ exitOk <- newIORef False
+
absRootDir <- canonicalizePath rootDir
hSetBuffering serverIn NoBuffering
hSetBuffering serverOut NoBuffering
+ -- This is required to make sure that we don’t get any
+ -- newline conversion or weird encoding issues.
+ hSetBinaryMode serverIn True
+ hSetBinaryMode serverOut True
reqMap <- newMVar newRequestMap
messageChan <- newChan
initRsp <- newEmptyMVar
+ mainThreadId <- myThreadId
+
let context = SessionContext serverIn absRootDir messageChan reqMap initRsp config caps
initState = SessionState (IdInt 0) mempty mempty 0 False Nothing
-
- threadId <- forkIO $ void $ serverHandler serverOut context
- (result, _) <- runSession context initState session
-
- killThread threadId
-
+ errorHandler ex = do x <- readIORef exitOk
+ unless x $ throwTo mainThreadId (ex :: SessionException)
+ launchServerHandler = forkIO $ catch (serverHandler serverOut context) errorHandler
+ (result, _) <- bracket
+ launchServerHandler
+ (\tid -> do runSession context initState sendExitMessage
+ killThread tid
+ atomicWriteIORef exitOk True)
+ (const $ runSession context initState session)
return result
updateStateC :: ConduitM FromServerMessage FromServerMessage (StateT SessionState (ReaderT SessionContext IO)) ()
let List diags = n ^. params . diagnostics
doc = n ^. params . uri
modify (\s ->
- let newDiags = Map.insert doc diags (curDiagnostics s)
+ let newDiags = Map.insert (toNormalizedUri doc) diags (curDiagnostics s)
in s { curDiagnostics = newDiags })
updateState (ReqApplyWorkspaceEdit r) = do
newVFS <- liftIO $ changeFromServerVFS (vfs s) r
return $ s { vfs = newVFS }
- let groupedParams = groupBy (\a b -> (a ^. textDocument == b ^. textDocument)) allChangeParams
+ let groupedParams = groupBy (\a b -> a ^. textDocument == b ^. textDocument) allChangeParams
mergedParams = map mergeParams groupedParams
-- TODO: Don't do this when replaying a session
forM_ bumpedVersions $ \(VersionedTextDocumentIdentifier uri v) ->
modify $ \s ->
let oldVFS = vfs s
- update (VirtualFile oldV t) = VirtualFile (fromMaybe oldV v) t
- newVFS = Map.adjust update uri oldVFS
+ update (VirtualFile oldV t mf) = VirtualFile (fromMaybe oldV v) t mf
+ newVFS = Map.adjust update (toNormalizedUri uri) oldVFS
in s { vfs = newVFS }
where checkIfNeedsOpened uri = do
ctx <- ask
-- if its not open, open it
- unless (uri `Map.member` oldVFS) $ do
+ unless (toNormalizedUri uri `Map.member` oldVFS) $ do
let fp = fromJust $ uriToFilePath uri
contents <- liftIO $ T.readFile fp
let item = TextDocumentItem (filePathToUri fp) "" 0 contents
logMsg LogClient msg
liftIO $ B.hPut h (addHeader $ encode msg)
--- | Execute a block f that will throw a 'TimeoutException'
+sendExitMessage :: (MonadIO m, HasReader SessionContext m) => m ()
+sendExitMessage = sendMessage (NotificationMessage "2.0" Exit ExitParams)
+
+-- | Execute a block f that will throw a 'Timeout' exception
-- after duration seconds. This will override the global timeout
-- for waiting for messages to arrive defined in 'SessionConfig'.
withTimeout :: Int -> Session a -> Session a
| otherwise = Cyan
showPretty = B.unpack . encodePretty
+
projects / lsp-test.git / blobdiff