ghc-mod/Language/Haskell/GhcMod/Debug.hs

130 lines
4.3 KiB
Haskell
Raw Normal View History

2015-03-28 01:33:42 +00:00
module Language.Haskell.GhcMod.Debug (debugInfo, rootInfo, componentInfo) where
2013-03-04 02:21:41 +00:00
import Control.Arrow (first)
2015-04-13 22:51:03 +00:00
import Control.Applicative
import Control.Monad
import qualified Data.Map as Map
import qualified Data.Set as Set
2015-03-28 01:33:42 +00:00
import Data.Char
2015-04-13 22:51:03 +00:00
import Data.List.Split
import Text.PrettyPrint
2014-05-11 22:40:00 +00:00
import Language.Haskell.GhcMod.Convert
import Language.Haskell.GhcMod.Monad
2013-05-17 01:00:01 +00:00
import Language.Haskell.GhcMod.Types
import Language.Haskell.GhcMod.Internal
import Language.Haskell.GhcMod.Target
import Language.Haskell.GhcMod.Pretty
2015-04-13 22:51:03 +00:00
import Language.Haskell.GhcMod.Utils
2013-03-04 02:21:41 +00:00
----------------------------------------------------------------
2013-05-20 05:28:56 +00:00
-- | Obtaining debug information.
debugInfo :: IOish m => GhcModT m String
debugInfo = do
Options {..} <- options
Cradle {..} <- cradle
2014-03-20 07:21:48 +00:00
cabal <-
2015-08-12 07:25:13 +00:00
case cradleProjectType of
CabalProject -> cabalDebug
_ -> return []
pkgOpts <- packageGhcOptions
return $ unlines $
[ "Root directory: " ++ cradleRootDir
, "Current directory: " ++ cradleCurrentDir
, "GHC Package flags:\n" ++ render (nest 4 $
fsep $ map text pkgOpts)
, "GHC System libraries: " ++ ghcLibDir
, "GHC user options:\n" ++ render (nest 4 $
fsep $ map text ghcUserOptions)
] ++ cabal
cabalDebug :: IOish m => GhcModT m [String]
cabalDebug = do
Cradle {..} <- cradle
mcs <- cabalResolvedComponents
let entrypoints = Map.map gmcEntrypoints mcs
graphs = Map.map gmcHomeModuleGraph mcs
opts = Map.map gmcGhcOpts mcs
srcOpts = Map.map gmcGhcSrcOpts mcs
return $
[ "Cabal file: " ++ show cradleCabalFile
, "Cabal entrypoints:\n" ++ render (nest 4 $
mapDoc gmComponentNameDoc smpDoc entrypoints)
, "Cabal components:\n" ++ render (nest 4 $
mapDoc gmComponentNameDoc graphDoc graphs)
, "GHC Cabal options:\n" ++ render (nest 4 $
mapDoc gmComponentNameDoc (fsep . map text) opts)
, "GHC search path options:\n" ++ render (nest 4 $
mapDoc gmComponentNameDoc (fsep . map text) srcOpts)
]
2015-03-28 01:33:42 +00:00
componentInfo :: IOish m => [String] -> GhcModT m String
componentInfo ts = do
2015-04-12 00:48:05 +00:00
-- TODO: most of this is copypasta of targetGhcOptions. Factor out more
-- useful function from there.
2015-03-28 01:33:42 +00:00
crdl <- cradle
2015-04-13 22:51:03 +00:00
sefnmn <- Set.fromList `liftM` mapM guessModuleFile ts
mcs <- cabalResolvedComponents
2015-04-12 00:48:05 +00:00
let
mdlcs = moduleComponents mcs `zipMap` Set.toList sefnmn
candidates = findCandidates $ map snd mdlcs
cn = pickComponent candidates
opts <- targetGhcOptions crdl sefnmn
2015-03-28 01:33:42 +00:00
return $ unlines $
2015-04-12 00:48:05 +00:00
[ "Matching Components:\n" ++ render (nest 4 $
alistDoc (either text mnDoc) (setDoc gmComponentNameDoc) mdlcs)
, "Picked Component:\n" ++ render (nest 4 $
gmComponentNameDoc cn)
, "GHC Cabal options:\n" ++ render (nest 4 $ fsep $ map text opts)
2015-03-28 01:33:42 +00:00
]
2015-04-12 00:48:05 +00:00
where
zipMap f l = l `zip` (f `map` l)
2015-03-28 01:33:42 +00:00
2015-04-13 22:51:03 +00:00
guessModuleFile :: MonadIO m => String -> m (Either FilePath ModuleName)
guessModuleFile m
| (isUpper . head .&&. (all $ all $ isAlphaNum .||. (=='.')) . splitOn ".") m =
return $ Right $ mkModuleName m
where
infixr 1 .||.
infixr 2 .&&.
(.||.) = liftA2 (||)
(.&&.) = liftA2 (&&)
guessModuleFile str = Left `liftM` liftIO (canonFilePath str)
2015-03-28 01:33:42 +00:00
graphDoc :: GmModuleGraph -> Doc
graphDoc GmModuleGraph{..} =
2015-04-12 00:48:05 +00:00
mapDoc mpDoc smpDoc' gmgGraph
where
smpDoc' smp = vcat $ map mpDoc' $ Set.toList smp
mpDoc' = text . moduleNameString . mpModule
2015-04-12 00:48:05 +00:00
setDoc :: (a -> Doc) -> Set.Set a -> Doc
setDoc f s = vcat $ map f $ Set.toList s
smpDoc :: Set.Set ModulePath -> Doc
2015-04-12 00:48:05 +00:00
smpDoc smp = setDoc mpDoc smp
mpDoc :: ModulePath -> Doc
mpDoc (ModulePath mn fn) = text (moduleNameString mn) <+> parens (text fn)
2015-04-12 00:48:05 +00:00
mnDoc :: ModuleName -> Doc
mnDoc mn = text (moduleNameString mn)
alistDoc :: Ord k => (k -> Doc) -> (a -> Doc) -> [(k, a)] -> Doc
alistDoc fk fa alist = mapDoc fk fa (Map.fromList alist)
mapDoc :: (k -> Doc) -> (a -> Doc) -> Map.Map k a -> Doc
mapDoc kd ad m = vcat $
map (uncurry ($+$)) $ map (first kd) $ Map.toList $ Map.map (nest 4 . ad) m
2014-03-20 07:21:48 +00:00
----------------------------------------------------------------
-- | Obtaining root information.
rootInfo :: IOish m => GhcModT m String
rootInfo = convert' =<< cradleRootDir <$> cradle