265 lines
9.3 KiB
Haskell
265 lines
9.3 KiB
Haskell
|
|
import Control.Concurrent
|
|
import Control.Concurrent.STM
|
|
import Control.Exception as E
|
|
import Control.Lens
|
|
import Control.Monad
|
|
|
|
import Data.Default
|
|
import Data.Foldable
|
|
import qualified Data.Text as Text
|
|
import Data.Text (Text)
|
|
import Data.String (fromString)
|
|
import Data.String.Interpolate (i)
|
|
|
|
import qualified Language.Haskell.LSP.Control as CTRL
|
|
import qualified Language.Haskell.LSP.Core as Core
|
|
import Language.Haskell.LSP.Diagnostics
|
|
import Language.Haskell.LSP.Messages as Msg
|
|
import qualified Language.Haskell.LSP.Types as J
|
|
import qualified Language.Haskell.LSP.Types.Lens as J
|
|
import qualified Language.Haskell.LSP.Utility as U
|
|
import Language.Haskell.LSP.VFS
|
|
|
|
import System.Exit
|
|
import qualified System.Log as L
|
|
|
|
import Duplo.Pretty
|
|
|
|
import Parser
|
|
import ParseTree
|
|
import Range
|
|
import Product
|
|
import AST hiding (def)
|
|
import qualified AST.Find as Find
|
|
-- import Error
|
|
|
|
main :: IO ()
|
|
main = do
|
|
return ()
|
|
for_ [1.. 100] \_ -> do
|
|
print . length . show . pp =<< sample' "../../../src/test/contracts/loop.ligo"
|
|
-- errCode <- mainLoop
|
|
-- exit errCode
|
|
|
|
-- mainLoop :: IO Int
|
|
-- mainLoop = do
|
|
-- chan <- atomically newTChan :: IO (TChan FromClientMessage)
|
|
|
|
-- let
|
|
-- callbacks = Core.InitializeCallbacks
|
|
-- { Core.onInitialConfiguration = const $ Right ()
|
|
-- , Core.onConfigurationChange = const $ Right ()
|
|
-- , Core.onStartup = \lFuns -> do
|
|
-- _ <- forkIO $ eventLoop lFuns chan
|
|
-- return Nothing
|
|
-- }
|
|
|
|
-- Core.setupLogger (Just "log.txt") [] L.INFO
|
|
-- CTRL.run callbacks (lspHandlers chan) lspOptions (Just "log.txt")
|
|
-- `catches`
|
|
-- [ Handler \(e :: SomeException) -> do
|
|
-- print e
|
|
-- return 1
|
|
-- ]
|
|
|
|
-- syncOptions :: J.TextDocumentSyncOptions
|
|
-- syncOptions = J.TextDocumentSyncOptions
|
|
-- { J._openClose = Just True
|
|
-- , J._change = Just J.TdSyncIncremental
|
|
-- , J._willSave = Just False
|
|
-- , J._willSaveWaitUntil = Just False
|
|
-- , J._save = Just $ J.SaveOptions $ Just False
|
|
-- }
|
|
|
|
-- lspOptions :: Core.Options
|
|
-- lspOptions = def
|
|
-- { Core.textDocumentSync = Just syncOptions
|
|
-- , Core.executeCommandCommands = Just ["lsp-hello-command"]
|
|
-- }
|
|
|
|
-- lspHandlers :: TChan FromClientMessage -> Core.Handlers
|
|
-- lspHandlers rin = def
|
|
-- { Core.initializedHandler = Just $ passHandler rin NotInitialized
|
|
-- , Core.definitionHandler = Just $ passHandler rin ReqDefinition
|
|
-- , Core.referencesHandler = Just $ passHandler rin ReqFindReferences
|
|
-- , Core.didOpenTextDocumentNotificationHandler = Just $ passHandler rin NotDidOpenTextDocument
|
|
-- , Core.didSaveTextDocumentNotificationHandler = Just $ passHandler rin NotDidSaveTextDocument
|
|
-- , Core.didChangeTextDocumentNotificationHandler = Just $ passHandler rin NotDidChangeTextDocument
|
|
-- , Core.didCloseTextDocumentNotificationHandler = Just $ passHandler rin NotDidCloseTextDocument
|
|
-- , Core.cancelNotificationHandler = Just $ passHandler rin NotCancelRequestFromClient
|
|
-- , Core.responseHandler = Just $ responseHandlerCb rin
|
|
-- , Core.codeActionHandler = Just $ passHandler rin ReqCodeAction
|
|
-- , Core.executeCommandHandler = Just $ passHandler rin ReqExecuteCommand
|
|
-- }
|
|
|
|
-- passHandler :: TChan FromClientMessage -> (a -> FromClientMessage) -> Core.Handler a
|
|
-- passHandler rin c notification = do
|
|
-- atomically $ writeTChan rin (c notification)
|
|
|
|
-- responseHandlerCb :: TChan FromClientMessage -> Core.Handler J.BareResponseMessage
|
|
-- responseHandlerCb _rin resp = do
|
|
-- U.logs $ "******** got ResponseMessage, ignoring:" ++ show resp
|
|
|
|
-- send :: Core.LspFuncs () -> FromServerMessage -> IO ()
|
|
-- send = Core.sendFunc
|
|
|
|
-- nextID :: Core.LspFuncs () -> IO J.LspId
|
|
-- nextID = Core.getNextReqId
|
|
|
|
-- eventLoop :: Core.LspFuncs () -> TChan FromClientMessage -> IO ()
|
|
-- eventLoop funs chan = do
|
|
-- forever do
|
|
-- msg <- atomically (readTChan chan)
|
|
|
|
-- U.logs [i|Client: ${msg}|]
|
|
|
|
-- case msg of
|
|
-- RspFromClient {} -> do
|
|
-- return ()
|
|
|
|
-- NotInitialized _notif -> do
|
|
-- let
|
|
-- registration = J.Registration
|
|
-- "lsp-haskell-registered"
|
|
-- J.WorkspaceExecuteCommand
|
|
-- Nothing
|
|
-- registrations = J.RegistrationParams $ J.List [registration]
|
|
|
|
-- rid <- nextID funs
|
|
-- send funs
|
|
-- $ ReqRegisterCapability
|
|
-- $ fmServerRegisterCapabilityRequest rid registrations
|
|
|
|
-- NotDidOpenTextDocument notif -> do
|
|
-- let
|
|
-- doc = notif
|
|
-- ^.J.params
|
|
-- .J.textDocument
|
|
-- .J.uri
|
|
|
|
-- ver = notif
|
|
-- ^.J.params
|
|
-- .J.textDocument
|
|
-- .J.version
|
|
|
|
-- collectErrors funs
|
|
-- (J.toNormalizedUri doc)
|
|
-- (J.uriToFilePath doc)
|
|
-- (Just ver)
|
|
|
|
-- NotDidChangeTextDocument notif -> do
|
|
-- let
|
|
-- doc = notif
|
|
-- ^.J.params
|
|
-- .J.textDocument
|
|
-- .J.uri
|
|
|
|
-- collectErrors funs
|
|
-- (J.toNormalizedUri doc)
|
|
-- (J.uriToFilePath doc)
|
|
-- (Just 0)
|
|
|
|
-- ReqDefinition req -> do
|
|
-- stopDyingAlready funs req do
|
|
-- let uri = req^.J.params.J.textDocument.J.uri
|
|
-- let pos = posToRange $ req^.J.params.J.position
|
|
-- tree <- loadByVFS funs uri
|
|
-- case Find.definitionOf pos tree of
|
|
-- Just defPos -> do
|
|
-- respondWith funs req RspDefinition $ J.MultiLoc [J.Location uri $ rangeToLoc defPos]
|
|
-- Nothing -> do
|
|
-- respondWith funs req RspDefinition $ J.MultiLoc []
|
|
|
|
-- ReqFindReferences req -> do
|
|
-- stopDyingAlready funs req do
|
|
-- let uri = req^.J.params.J.textDocument.J.uri
|
|
-- let pos = posToRange $ req^.J.params.J.position
|
|
-- tree <- loadFromVFS funs uri
|
|
-- case Find.referencesOf pos tree of
|
|
-- Just refs -> do
|
|
-- let locations = J.Location uri . rangeToLoc <$> refs
|
|
-- respondWith funs req RspFindReferences $ J.List locations
|
|
-- Nothing -> do
|
|
-- respondWith funs req RspFindReferences $ J.List []
|
|
|
|
-- _ -> U.logs "unknown msg"
|
|
|
|
-- respondWith
|
|
-- :: Core.LspFuncs ()
|
|
-- -> J.RequestMessage J.ClientMethod req rsp
|
|
-- -> (J.ResponseMessage rsp -> FromServerMessage)
|
|
-- -> rsp
|
|
-- -> IO ()
|
|
-- respondWith funs req wrap rsp = Core.sendFunc funs $ wrap $ Core.makeResponseMessage req rsp
|
|
|
|
-- stopDyingAlready :: Core.LspFuncs () -> J.RequestMessage m a b -> IO () -> IO ()
|
|
-- stopDyingAlready funs req = flip catch \(e :: SomeException) -> do
|
|
-- Core.sendErrorResponseS (Core.sendFunc funs) (req^.J.id.to J.responseId) J.InternalError
|
|
-- $ fromString
|
|
-- $ "this happened: " ++ show e
|
|
|
|
-- posToRange :: J.Position -> Range
|
|
-- posToRange (J.Position l c) = Range (l + 1, c + 1, 0) (l + 1, c + 1, 0) ""
|
|
|
|
-- rangeToLoc :: Range -> J.Range
|
|
-- rangeToLoc (Range (a, b, _) (c, d, _) _) =
|
|
-- J.Range
|
|
-- (J.Position (a - 1) (b - 1))
|
|
-- (J.Position (c - 1) (d - 1))
|
|
|
|
-- loadFromVFS
|
|
-- :: Core.LspFuncs ()
|
|
-- -> J.Uri
|
|
-- -> IO (Pascal (Product [[ScopedDecl], Maybe Category, Range, [Text]]))
|
|
-- loadFromVFS funs uri = do
|
|
-- Just vf <- Core.getVirtualFileFunc funs $ J.toNormalizedUri uri
|
|
-- let txt = virtualFileText vf
|
|
-- let Just fin = J.uriToFilePath uri
|
|
-- (tree, _) <- runParser contract (Text fin txt)
|
|
-- return $ addLocalScopes tree
|
|
|
|
-- loadByURI
|
|
-- :: J.Uri
|
|
-- -> IO (Pascal (Product [[ScopedDecl], Maybe Category, Range, [Text]]))
|
|
-- loadByURI uri = do
|
|
-- case J.uriToFilePath uri of
|
|
-- Just fin -> do
|
|
-- (tree, _) <- runParser contract (Path fin)
|
|
-- return $ addLocalScopes tree
|
|
-- Nothing -> do
|
|
-- error $ "uriToFilePath " ++ show uri ++ " has failed. We all are doomed."
|
|
|
|
-- collectErrors
|
|
-- :: Core.LspFuncs ()
|
|
-- -> J.NormalizedUri
|
|
-- -> Maybe FilePath
|
|
-- -> Maybe Int
|
|
-- -> IO ()
|
|
-- collectErrors funs uri path version = do
|
|
-- case path of
|
|
-- Just fin -> do
|
|
-- (tree, errs) <- runParser contract (Path fin)
|
|
-- Core.publishDiagnosticsFunc funs 100 uri version
|
|
-- $ partitionBySource
|
|
-- $ map errorToDiag (errs <> errors tree)
|
|
|
|
-- Nothing -> error "TODO: implement URI file loading"
|
|
|
|
-- errorToDiag :: Error ASTInfo -> J.Diagnostic
|
|
-- errorToDiag (Expected what _ (getRange -> (Range (sl, sc, _) (el, ec, _) _))) =
|
|
-- J.Diagnostic
|
|
-- (J.Range begin end)
|
|
-- (Just J.DsError)
|
|
-- Nothing
|
|
-- (Just "ligo-lsp")
|
|
-- (Text.pack [i|Expected #{what}|])
|
|
-- (Just $ J.List[])
|
|
-- where
|
|
-- begin = J.Position (sl - 1) (sc - 1)
|
|
-- end = J.Position (el - 1) (ec - 1)
|
|
|
|
-- exit :: Int -> IO ()
|
|
-- exit 0 = exitSuccess
|
|
-- exit n = exitWith (ExitFailure n)
|