41161aa390
* Rewriting Dhall.LSP.Backend.Dhall: Implement new API The old "backend" consisted of a random collection of ways to invoke Dhall: - runDhall :: FilePath -> Text -> IO (Expr Src X) - runDhallSafe :: FilePath -> Text -> IO (Maybe (Expr Src X)) - loadDhallExprSafe :: FilePath -> Text -> IO (Maybe (Expr Src X)) The new backend exposes a slightly more though-out API. This also lays the foundation for performance improvements in the dhall lsp server via caching. * Reorder code in Dhall.LSP.Backend.Dhall * Remove unused constructor * Rewrite and document Backend.Formatting * Refactor Dhall.LSP.Backend.Linting * Refactor Dhall.LSP.Backend.ToJSON * Adapt Diagnostics backend to the new Dhall API * Remove old Dhall backend API * Implement caching; revamp LSP frontend This commit implements caching of Dhall expressions: we only need to fetch, typecheck and normalise each import once per session, unless they change! This means that `dhall-lsp-server` is now viable for non-trivial Dhall projects, for example probing around in `dhall-nethack` everything feels near-instantaneous once the imports have been resolved. This implementation currently has a bug: we don't invalidate imports transitively, i.e. if A.dhall loads B.dhall and B.dhall changes we do not discard the cached version of A.dhall. This should be reasonably easy to fix given some time with Dhall's import graph. Furthermore, there is some cleaning up left to do: - Fix warnings - Reorganise things in a less ad-hoc way - Make the code a bit prettier * Fix caching of errors * Use `bimap` instead of `first` and `second` * Re-export `Dhall.lint` rather than aliasing Rids us of some boilderplate * Use MVar instead of TVar for server state The main benefit is that we get to use `modifyMVar_` which does updating of the shared state for us (and gracefully handles any uncaught exceptions). * Don't invalidate hashed imports Fixes a misinterpretation on my end of the correct behaviour regarding the caching of imports. Quoting @Gabriel439: > A hashed import is valid indefinitely once it is successfully > resolved, even when the underlying import later becomes broken. That's > why missing sha256:… works so long as the cache has that import cached > (and this behavior is part of the standard). * Cleanup Dhall.LSP.Backend.Dhall a little bit * Add note about fixing cache invalidation * Use TemplateHaskell to generate state lenses * Make types of `typeAt` and `annotateLet` more expressive Both assume the input to be well-typed; by using `WellTyped` rather than `Expr Src X` as the type of their input we can make this explicit. This change exposed a bug (also fixed in this commit) in the type-on-hover functionality: we run `typeAt` only if the input was well-typed _the last time we checked it_ (which was at the last save); this means that if the code changed without being written to disk we would happily try to normalise (in `typeAt`) non-well-typed code... * Fix type of typecheck Typecheck returned the well-typed _type_ of a given expression, while I was assuming it would certify the input to be well-typed. Silly indeed. * Remove `checkDhall` from Dhall.Backend.Diagnostics Removes the left-over stub from the change to the new Dhall backend. * Update comments and remove TODO note * Remove superfluous parentheses * Simplify MonadState code via lens combinators * Use `guard` instead of matching on True * Remove more superfluous parentheses
34 lines
849 B
Haskell
34 lines
849 B
Haskell
-- | Miscellaneous utility functions
|
|
|
|
module Dhall.LSP.Util (
|
|
tshow,
|
|
lines',
|
|
rightToMaybe,
|
|
unlines'
|
|
) where
|
|
|
|
import Data.Text
|
|
import Data.List.NonEmpty
|
|
|
|
-- | Shorthand for @pack . show@. Useful since we are mostly working with Text
|
|
-- rather than String.
|
|
tshow :: Show a => a -> Text
|
|
tshow = pack . show
|
|
|
|
-- | A variant of @Data.Text.lines@ that does not swallow the last empty. Always
|
|
-- returns at least the empty line!
|
|
lines' :: Text -> NonEmpty Text
|
|
lines' text =
|
|
case split (== '\n') text of
|
|
[] -> "" :| [] -- this case never occurs!
|
|
l : ls -> l :| ls
|
|
|
|
-- | A variant of @Data.Text.unlines@ that is the exact inverse to @lines'@ (and
|
|
-- vice-versa).
|
|
unlines' :: [Text] -> Text
|
|
unlines' = intercalate "\n"
|
|
|
|
rightToMaybe :: Either a b -> Maybe b
|
|
rightToMaybe (Right b) = Just b
|
|
rightToMaybe (Left _) = Nothing
|