{-# LANGUAGE ScopedTypeVariables #-}
module StaticLS.HIE.File (
getHieFileFromTdi,
getHieFile,
modToHieFile,
modToSrcFile,
srcFilePathToHieFilePath,
hieFilePathToSrcFilePath,
getHieFileMap,
hieFileMapToSrcMap,
)
where
import Control.Applicative ((<|>))
import Control.Exception (SomeException, catch)
import Control.Monad ((<=<))
import Control.Monad.IO.Unlift (MonadIO, liftIO)
import Control.Monad.Trans.Except (ExceptT (..))
import Control.Monad.Trans.Maybe (MaybeT (..), exceptToMaybeT, runMaybeT)
import Data.Bifunctor (first, second)
import qualified Data.List as List
import qualified Data.List.Extra as List
import qualified Data.Map as Map
import qualified GHC
import qualified GHC.Iface.Ext.Binary as GHC
import qualified GHC.Iface.Ext.Types as GHC
import GHC.Stack (HasCallStack)
import qualified GHC.Types.Name.Cache as GHC
import qualified HieDb
import qualified Language.LSP.Types as LSP
import StaticLS.HIE.File.Except
import StaticLS.Maybe (flatMaybeT, toAlt)
import StaticLS.StaticEnv
import qualified System.Directory as Dir
import System.FilePath ((-<.>), (</>))
type SrcFilePath = FilePath
getHieFileFromTdi :: (HasStaticEnv m, MonadIO m) => LSP.TextDocumentIdentifier -> MaybeT m GHC.HieFile
getHieFileFromTdi :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
TextDocumentIdentifier -> MaybeT m HieFile
getHieFileFromTdi = ExceptT HieFileReadException m HieFile -> MaybeT m HieFile
forall (m :: * -> *) e a. Functor m => ExceptT e m a -> MaybeT m a
exceptToMaybeT (ExceptT HieFileReadException m HieFile -> MaybeT m HieFile)
-> (HieFilePath -> ExceptT HieFileReadException m HieFile)
-> HieFilePath
-> MaybeT m HieFile
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HieFilePath -> ExceptT HieFileReadException m HieFile
forall (m :: * -> *).
(HasCallStack, HasStaticEnv m, MonadIO m) =>
HieFilePath -> ExceptT HieFileReadException m HieFile
getHieFile (HieFilePath -> MaybeT m HieFile)
-> (TextDocumentIdentifier -> MaybeT m HieFilePath)
-> TextDocumentIdentifier
-> MaybeT m HieFile
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< TextDocumentIdentifier -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
TextDocumentIdentifier -> MaybeT m HieFilePath
tdiToHieFilePath
tdiToHieFilePath :: (HasStaticEnv m, MonadIO m) => LSP.TextDocumentIdentifier -> MaybeT m HieFilePath
tdiToHieFilePath :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
TextDocumentIdentifier -> MaybeT m HieFilePath
tdiToHieFilePath = HieFilePath -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePath (HieFilePath -> MaybeT m HieFilePath)
-> (TextDocumentIdentifier -> MaybeT m HieFilePath)
-> TextDocumentIdentifier
-> MaybeT m HieFilePath
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (m (Maybe HieFilePath) -> MaybeT m HieFilePath
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (m (Maybe HieFilePath) -> MaybeT m HieFilePath)
-> (TextDocumentIdentifier -> m (Maybe HieFilePath))
-> TextDocumentIdentifier
-> MaybeT m HieFilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe HieFilePath -> m (Maybe HieFilePath)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe HieFilePath -> m (Maybe HieFilePath))
-> (TextDocumentIdentifier -> Maybe HieFilePath)
-> TextDocumentIdentifier
-> m (Maybe HieFilePath)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Uri -> Maybe HieFilePath
LSP.uriToFilePath (Uri -> Maybe HieFilePath)
-> (TextDocumentIdentifier -> Uri)
-> TextDocumentIdentifier
-> Maybe HieFilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (._uri))
modToHieFile :: (HasStaticEnv m, MonadIO m) => GHC.ModuleName -> MaybeT m GHC.HieFile
modToHieFile :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
ModuleName -> MaybeT m HieFile
modToHieFile = ExceptT HieFileReadException m HieFile -> MaybeT m HieFile
forall (m :: * -> *) e a. Functor m => ExceptT e m a -> MaybeT m a
exceptToMaybeT (ExceptT HieFileReadException m HieFile -> MaybeT m HieFile)
-> (HieFilePath -> ExceptT HieFileReadException m HieFile)
-> HieFilePath
-> MaybeT m HieFile
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HieFilePath -> ExceptT HieFileReadException m HieFile
forall (m :: * -> *).
(HasCallStack, HasStaticEnv m, MonadIO m) =>
HieFilePath -> ExceptT HieFileReadException m HieFile
getHieFile (HieFilePath -> MaybeT m HieFile)
-> (ModuleName -> MaybeT m HieFilePath)
-> ModuleName
-> MaybeT m HieFile
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ModuleName -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
ModuleName -> MaybeT m HieFilePath
modToHieFilePath
modToSrcFile :: (HasStaticEnv m, MonadIO m) => GHC.ModuleName -> MaybeT m SrcFilePath
modToSrcFile :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
ModuleName -> MaybeT m HieFilePath
modToSrcFile = HieFilePath -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
hieFilePathToSrcFilePath (HieFilePath -> MaybeT m HieFilePath)
-> (ModuleName -> MaybeT m HieFilePath)
-> ModuleName
-> MaybeT m HieFilePath
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ModuleName -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
ModuleName -> MaybeT m HieFilePath
modToHieFilePath
srcFilePathToHieFilePath :: (HasStaticEnv m, MonadIO m) => SrcFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePath :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePath HieFilePath
srcPath =
HieFilePath -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathHieDb HieFilePath
srcPath
MaybeT m HieFilePath
-> MaybeT m HieFilePath -> MaybeT m HieFilePath
forall a. MaybeT m a -> MaybeT m a -> MaybeT m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HieFilePath -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathFromFile HieFilePath
srcPath
hieFilePathToSrcFilePath :: (HasStaticEnv m, MonadIO m) => HieFilePath -> MaybeT m SrcFilePath
hieFilePathToSrcFilePath :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
hieFilePathToSrcFilePath = HieFilePath -> MaybeT m HieFilePath
forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
hieFilePathToSrcFilePathFromFile
getHieFile :: (HasCallStack, HasStaticEnv m, MonadIO m) => HieFilePath -> ExceptT HieFileReadException m GHC.HieFile
getHieFile :: forall (m :: * -> *).
(HasCallStack, HasStaticEnv m, MonadIO m) =>
HieFilePath -> ExceptT HieFileReadException m HieFile
getHieFile HieFilePath
hieFilePath = do
StaticEnv
staticEnv <- ExceptT HieFileReadException m StaticEnv
forall (m :: * -> *). HasStaticEnv m => m StaticEnv
getStaticEnv
Either HieFileReadException HieFileResult
result <-
IO (Either HieFileReadException HieFileResult)
-> ExceptT
HieFileReadException m (Either HieFileReadException HieFileResult)
forall a. IO a -> ExceptT HieFileReadException m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
( (Either HieHeader HieFileResult
-> Either HieFileReadException HieFileResult)
-> IO (Either HieHeader HieFileResult)
-> IO (Either HieFileReadException HieFileResult)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
((HieHeader -> HieFileReadException)
-> Either HieHeader HieFileResult
-> Either HieFileReadException HieFileResult
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first HieHeader -> HieFileReadException
HieFileVersionException)
((HieHeader -> Bool)
-> NameCache -> HieFilePath -> IO (Either HieHeader HieFileResult)
GHC.readHieFileWithVersion (Bool -> HieHeader -> Bool
forall a b. a -> b -> a
const Bool
True) StaticEnv
staticEnv.nameCache HieFilePath
hieFilePath)
IO (Either HieFileReadException HieFileResult)
-> (SomeException
-> IO (Either HieFileReadException HieFileResult))
-> IO (Either HieFileReadException HieFileResult)
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`catch` (\(SomeException
_ :: SomeException) -> Either HieFileReadException HieFileResult
-> IO (Either HieFileReadException HieFileResult)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either HieFileReadException HieFileResult
-> IO (Either HieFileReadException HieFileResult))
-> (HieFileReadException
-> Either HieFileReadException HieFileResult)
-> HieFileReadException
-> IO (Either HieFileReadException HieFileResult)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HieFileReadException -> Either HieFileReadException HieFileResult
forall a b. a -> Either a b
Left (HieFileReadException
-> IO (Either HieFileReadException HieFileResult))
-> HieFileReadException
-> IO (Either HieFileReadException HieFileResult)
forall a b. (a -> b) -> a -> b
$ HieFileReadException
HieFileReadException)
)
m (Either HieFileReadException HieFile)
-> ExceptT HieFileReadException m HieFile
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either HieFileReadException HieFile)
-> ExceptT HieFileReadException m HieFile)
-> m (Either HieFileReadException HieFile)
-> ExceptT HieFileReadException m HieFile
forall a b. (a -> b) -> a -> b
$ Either HieFileReadException HieFile
-> m (Either HieFileReadException HieFile)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((HieFileResult -> HieFile)
-> Either HieFileReadException HieFileResult
-> Either HieFileReadException HieFile
forall b c a. (b -> c) -> Either a b -> Either a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second HieFileResult -> HieFile
GHC.hie_file_result Either HieFileReadException HieFileResult
result)
srcFilePathToHieFilePathHieDb :: (HasStaticEnv m, MonadIO m) => SrcFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathHieDb :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathHieDb HieFilePath
srcPath = do
HieFilePath
absSrcPath <- IO HieFilePath -> MaybeT m HieFilePath
forall a. IO a -> MaybeT m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HieFilePath -> MaybeT m HieFilePath)
-> IO HieFilePath -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ HieFilePath -> IO HieFilePath
Dir.makeAbsolute HieFilePath
srcPath
Just HieModuleRow
hieModRow <- (HieDb -> IO (Maybe HieModuleRow)) -> MaybeT m (Maybe HieModuleRow)
forall (m :: * -> *) a.
(HasStaticEnv m, MonadIO m) =>
(HieDb -> IO a) -> MaybeT m a
runHieDbMaybeT ((HieDb -> IO (Maybe HieModuleRow))
-> MaybeT m (Maybe HieModuleRow))
-> (HieDb -> IO (Maybe HieModuleRow))
-> MaybeT m (Maybe HieModuleRow)
forall a b. (a -> b) -> a -> b
$ \HieDb
hieDb -> do
HieDb -> HieFilePath -> IO (Maybe HieModuleRow)
HieDb.lookupHieFileFromSource HieDb
hieDb HieFilePath
absSrcPath
HieFilePath -> MaybeT m HieFilePath
forall a. a -> MaybeT m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HieFilePath -> MaybeT m HieFilePath)
-> HieFilePath -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ HieModuleRow -> HieFilePath
HieDb.hieModuleHieFile HieModuleRow
hieModRow
modToHieFilePath :: (HasStaticEnv m, MonadIO m) => GHC.ModuleName -> MaybeT m HieFilePath
modToHieFilePath :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
ModuleName -> MaybeT m HieFilePath
modToHieFilePath ModuleName
modName =
MaybeT m (Maybe HieFilePath) -> MaybeT m HieFilePath
forall (m :: * -> *) a. Monad m => MaybeT m (Maybe a) -> MaybeT m a
flatMaybeT (MaybeT m (Maybe HieFilePath) -> MaybeT m HieFilePath)
-> MaybeT m (Maybe HieFilePath) -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ (HieDb -> IO (Maybe HieFilePath)) -> MaybeT m (Maybe HieFilePath)
forall (m :: * -> *) a.
(HasStaticEnv m, MonadIO m) =>
(HieDb -> IO a) -> MaybeT m a
runHieDbMaybeT ((HieDb -> IO (Maybe HieFilePath)) -> MaybeT m (Maybe HieFilePath))
-> (HieDb -> IO (Maybe HieFilePath))
-> MaybeT m (Maybe HieFilePath)
forall a b. (a -> b) -> a -> b
$ \HieDb
hieDb ->
MaybeT IO HieFilePath -> IO (Maybe HieFilePath)
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT IO HieFilePath -> IO (Maybe HieFilePath))
-> MaybeT IO HieFilePath -> IO (Maybe HieFilePath)
forall a b. (a -> b) -> a -> b
$ do
Right Unit
unitId <- IO (Either HieDbErr Unit) -> MaybeT IO (Either HieDbErr Unit)
forall a. IO a -> MaybeT IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (HieDb -> ModuleName -> IO (Either HieDbErr Unit)
HieDb.resolveUnitId HieDb
hieDb ModuleName
modName)
Just HieModuleRow
hieModRow <- IO (Maybe HieModuleRow) -> MaybeT IO (Maybe HieModuleRow)
forall a. IO a -> MaybeT IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe HieModuleRow) -> MaybeT IO (Maybe HieModuleRow))
-> IO (Maybe HieModuleRow) -> MaybeT IO (Maybe HieModuleRow)
forall a b. (a -> b) -> a -> b
$ HieDb -> ModuleName -> Unit -> IO (Maybe HieModuleRow)
HieDb.lookupHieFile HieDb
hieDb ModuleName
modName Unit
unitId
HieFilePath -> MaybeT IO HieFilePath
forall a. a -> MaybeT IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HieFilePath -> MaybeT IO HieFilePath)
-> HieFilePath -> MaybeT IO HieFilePath
forall a b. (a -> b) -> a -> b
$ HieModuleRow
hieModRow.hieModuleHieFile
srcDirs :: [FilePath]
srcDirs :: [HieFilePath]
srcDirs = [HieFilePath
"src/", HieFilePath
"lib/", HieFilePath
"app/", HieFilePath
"test/"]
hieFilePathToSrcFilePathFromFile :: (HasStaticEnv m, MonadIO m) => HieFilePath -> MaybeT m SrcFilePath
hieFilePathToSrcFilePathFromFile :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
hieFilePathToSrcFilePathFromFile HieFilePath
hiePath = do
HieFile
hieFile <- ExceptT HieFileReadException m HieFile -> MaybeT m HieFile
forall (m :: * -> *) e a. Functor m => ExceptT e m a -> MaybeT m a
exceptToMaybeT (ExceptT HieFileReadException m HieFile -> MaybeT m HieFile)
-> ExceptT HieFileReadException m HieFile -> MaybeT m HieFile
forall a b. (a -> b) -> a -> b
$ HieFilePath -> ExceptT HieFileReadException m HieFile
forall (m :: * -> *).
(HasCallStack, HasStaticEnv m, MonadIO m) =>
HieFilePath -> ExceptT HieFileReadException m HieFile
getHieFile HieFilePath
hiePath
IO HieFilePath -> MaybeT m HieFilePath
forall a. IO a -> MaybeT m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HieFilePath -> MaybeT m HieFilePath)
-> IO HieFilePath -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ HieFilePath -> IO HieFilePath
Dir.makeAbsolute HieFile
hieFile.hie_hs_file
srcFilePathToHieFilePathFromFile :: (HasStaticEnv m, MonadIO m) => SrcFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathFromFile :: forall (m :: * -> *).
(HasStaticEnv m, MonadIO m) =>
HieFilePath -> MaybeT m HieFilePath
srcFilePathToHieFilePathFromFile HieFilePath
srcPath = do
StaticEnv
staticEnv <- MaybeT m StaticEnv
forall (m :: * -> *). HasStaticEnv m => m StaticEnv
getStaticEnv
HieFilePath
absoluteRoot <- IO HieFilePath -> MaybeT m HieFilePath
forall a. IO a -> MaybeT m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HieFilePath -> MaybeT m HieFilePath)
-> IO HieFilePath -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ HieFilePath -> IO HieFilePath
Dir.makeAbsolute StaticEnv
staticEnv.wsRoot
HieFilePath
hieDir <- Maybe HieFilePath -> MaybeT m HieFilePath
forall (f :: * -> *) (g :: * -> *) a.
(Functor f, Foldable f, Alternative g) =>
f a -> g a
toAlt StaticEnv
staticEnv.hieFilesPath
let absoluteHieDir :: HieFilePath
absoluteHieDir = HieFilePath
absoluteRoot HieFilePath -> HieFilePath -> HieFilePath
</> HieFilePath
hieDir
absoluteSrcDirs :: [HieFilePath]
absoluteSrcDirs = (HieFilePath
absoluteRoot HieFilePath -> HieFilePath -> HieFilePath
</>) (HieFilePath -> HieFilePath) -> [HieFilePath] -> [HieFilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [HieFilePath]
srcDirs
HieFilePath
absoluteSrcPath <- IO HieFilePath -> MaybeT m HieFilePath
forall a. IO a -> MaybeT m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HieFilePath -> MaybeT m HieFilePath)
-> IO HieFilePath -> MaybeT m HieFilePath
forall a b. (a -> b) -> a -> b
$ HieFilePath -> IO HieFilePath
Dir.makeAbsolute HieFilePath
srcPath
let noPrefixSrcPath :: HieFilePath
noPrefixSrcPath =
(HieFilePath -> HieFilePath -> HieFilePath)
-> HieFilePath -> [HieFilePath] -> HieFilePath
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' ((HieFilePath -> HieFilePath -> HieFilePath)
-> HieFilePath -> HieFilePath -> HieFilePath
forall a b c. (a -> b -> c) -> b -> a -> c
flip HieFilePath -> HieFilePath -> HieFilePath
forall a. Eq a => [a] -> [a] -> [a]
List.dropPrefix) HieFilePath
absoluteSrcPath [HieFilePath]
absoluteSrcDirs
hiePath :: HieFilePath
hiePath = HieFilePath
absoluteHieDir HieFilePath -> HieFilePath -> HieFilePath
</> HieFilePath
noPrefixSrcPath HieFilePath -> HieFilePath -> HieFilePath
-<.> HieFilePath
".hie"
Bool
True <- IO Bool -> MaybeT m Bool
forall a. IO a -> MaybeT m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> MaybeT m Bool) -> IO Bool -> MaybeT m Bool
forall a b. (a -> b) -> a -> b
$ HieFilePath -> IO Bool
Dir.doesFileExist HieFilePath
hiePath
HieFilePath -> MaybeT m HieFilePath
forall a. a -> MaybeT m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HieFilePath
hiePath
data HieInfo = HieInfo
{ HieInfo -> HieFilePath
hieFilePath :: HieFilePath
, HieInfo -> HieFile
hieFile :: GHC.HieFile
}
getHieFileMap :: FilePath -> HieFilePath -> IO (Map.Map SrcFilePath HieInfo)
getHieFileMap :: HieFilePath -> HieFilePath -> IO (Map HieFilePath HieInfo)
getHieFileMap HieFilePath
wsroot HieFilePath
hieDir = do
let hieFullPath :: HieFilePath
hieFullPath = HieFilePath
wsroot HieFilePath -> HieFilePath -> HieFilePath
</> HieFilePath
hieDir
[HieFilePath]
hieFilePaths <- HieFilePath -> IO [HieFilePath]
HieDb.getHieFilesIn HieFilePath
hieFullPath
NameCache
nameCache <- Char -> [Name] -> IO NameCache
GHC.initNameCache Char
'a' []
[(HieFilePath, HieInfo)]
srcPathHieInfoPairs <- (HieFilePath -> IO (HieFilePath, HieInfo))
-> [HieFilePath] -> IO [(HieFilePath, HieInfo)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (NameCache -> HieFilePath -> IO (HieFilePath, HieInfo)
srcFileToHieFileInfo NameCache
nameCache) [HieFilePath]
hieFilePaths
Map HieFilePath HieInfo -> IO (Map HieFilePath HieInfo)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map HieFilePath HieInfo -> IO (Map HieFilePath HieInfo))
-> Map HieFilePath HieInfo -> IO (Map HieFilePath HieInfo)
forall a b. (a -> b) -> a -> b
$ [(HieFilePath, HieInfo)] -> Map HieFilePath HieInfo
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(HieFilePath, HieInfo)]
srcPathHieInfoPairs
where
srcFileToHieFileInfo :: GHC.NameCache -> HieFilePath -> IO (SrcFilePath, HieInfo)
srcFileToHieFileInfo :: NameCache -> HieFilePath -> IO (HieFilePath, HieInfo)
srcFileToHieFileInfo NameCache
nameCache HieFilePath
hieFilePath = do
HieFileResult
hieFileResult <- NameCache -> HieFilePath -> IO HieFileResult
GHC.readHieFile NameCache
nameCache HieFilePath
hieFilePath
HieFilePath
absSrcFilePath <- HieFilePath -> IO HieFilePath
Dir.makeAbsolute HieFileResult
hieFileResult.hie_file_result.hie_hs_file
HieFilePath
absHieFilePath <- HieFilePath -> IO HieFilePath
Dir.makeAbsolute HieFilePath
hieFilePath
let hieInfo :: HieInfo
hieInfo =
HieInfo
{ $sel:hieFilePath:HieInfo :: HieFilePath
hieFilePath = HieFilePath
absHieFilePath
, $sel:hieFile:HieInfo :: HieFile
hieFile = HieFileResult
hieFileResult.hie_file_result
}
(HieFilePath, HieInfo) -> IO (HieFilePath, HieInfo)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (HieFilePath
absSrcFilePath, HieInfo
hieInfo)
hieFileMapToSrcMap :: Map.Map SrcFilePath HieInfo -> Map.Map HieFilePath SrcFilePath
hieFileMapToSrcMap :: Map HieFilePath HieInfo -> Map HieFilePath HieFilePath
hieFileMapToSrcMap =
[(HieFilePath, HieFilePath)] -> Map HieFilePath HieFilePath
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(HieFilePath, HieFilePath)] -> Map HieFilePath HieFilePath)
-> (Map HieFilePath HieInfo -> [(HieFilePath, HieFilePath)])
-> Map HieFilePath HieInfo
-> Map HieFilePath HieFilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((HieFilePath, HieInfo) -> (HieFilePath, HieFilePath))
-> [(HieFilePath, HieInfo)] -> [(HieFilePath, HieFilePath)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(HieFilePath
srcPath, HieInfo
hieInfo) -> (HieInfo
hieInfo.hieFilePath, HieFilePath
srcPath)) ([(HieFilePath, HieInfo)] -> [(HieFilePath, HieFilePath)])
-> (Map HieFilePath HieInfo -> [(HieFilePath, HieInfo)])
-> Map HieFilePath HieInfo
-> [(HieFilePath, HieFilePath)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map HieFilePath HieInfo -> [(HieFilePath, HieInfo)]
forall k a. Map k a -> [(k, a)]
Map.toList