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

554 lines
17 KiB
Haskell
Raw Normal View History

{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, CPP, ScopedTypeVariables, RankNTypes #-}
2012-02-14 07:09:53 +00:00
2013-05-17 01:00:01 +00:00
module Language.Haskell.GhcMod.Gap (
Language.Haskell.GhcMod.Gap.ClsInst
, mkTarget
2013-03-12 13:15:23 +00:00
, withStyle
, setLogAction
2012-02-14 07:09:53 +00:00
, getSrcSpan
, getSrcFile
2014-04-27 12:26:03 +00:00
, withContext
2012-02-14 07:09:53 +00:00
, fOptions
, toStringBuffer
, showSeverityCaption
, setCabalPkg
2014-04-23 01:41:28 +00:00
, setHideAllPackages
2014-04-26 04:21:22 +00:00
, setDeferTypeErrors
2014-06-09 08:30:33 +00:00
, setWarnTypedHoles
2014-04-26 04:21:22 +00:00
, setDumpSplices
, isDumpSplices
, filterOutChildren
, infoThing
, pprInfo
, HasType(..)
2013-11-19 03:28:59 +00:00
, errorMsgSpan
2013-11-19 03:35:42 +00:00
, typeForUser
, nameForUser
, occNameForUser
2013-11-19 03:54:08 +00:00
, deSugar
, showDocWith
2014-02-06 12:34:40 +00:00
, GapThing(..)
, fromTyThing
2014-04-27 12:26:03 +00:00
, fileModSummary
2014-04-28 05:36:55 +00:00
, WarnFlags
, emptyWarnFlags
2014-07-15 03:35:45 +00:00
, GLMatch
, GLMatchI
2014-07-15 05:44:02 +00:00
, getClass
, occName
2015-01-16 14:47:56 +00:00
, listVisibleModuleNames
, listVisibleModules
, lookupModulePackageInAllPackages
2015-01-16 14:47:56 +00:00
, Language.Haskell.GhcMod.Gap.isSynTyCon
2015-03-05 15:50:06 +00:00
, parseModuleHeader
2012-02-14 07:09:53 +00:00
) where
import Control.Applicative hiding (empty)
2014-03-27 07:02:16 +00:00
import Control.Monad (filterM)
import CoreSyn (CoreExpr)
import Data.List (intersperse)
import Data.Maybe (catMaybes)
import Data.Time.Clock (UTCTime)
2015-08-03 05:51:23 +00:00
import Data.Traversable hiding (mapM)
2014-02-06 13:09:00 +00:00
import DataCon (dataConRepType)
2013-11-19 03:54:08 +00:00
import Desugar (deSugarExpr)
2012-02-14 07:09:53 +00:00
import DynFlags
import ErrUtils
import Exception
2012-02-14 07:09:53 +00:00
import FastString
import GhcMonad
2013-07-14 08:07:30 +00:00
import HscTypes
import NameSet
import OccName
2012-02-14 07:09:53 +00:00
import Outputable
2013-07-14 08:07:30 +00:00
import PprTyThing
2012-02-14 07:09:53 +00:00
import StringBuffer
import TcType
2014-02-06 13:09:00 +00:00
import Var (varType)
import System.Directory
2015-01-16 14:47:56 +00:00
2015-07-04 14:49:48 +00:00
import qualified Name
import qualified InstEnv
import qualified Pretty
import qualified StringBuffer as SB
2014-04-28 05:13:25 +00:00
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
import FamInstEnv
import ConLike (ConLike(..))
2014-02-06 13:12:07 +00:00
import PatSyn (patSynType)
2014-01-08 00:55:06 +00:00
#else
import TcRnTypes
#endif
#if __GLASGOW_HASKELL__ >= 706
import GHC hiding (ClsInst)
#else
import GHC hiding (Instance)
2013-07-02 09:29:08 +00:00
import Control.Arrow hiding ((<+>))
import Data.Convertible
2014-07-15 05:44:02 +00:00
import RdrName (rdrNameOcc)
#endif
2015-01-16 14:47:56 +00:00
#if __GLASGOW_HASKELL__ < 710
import UniqFM (eltsUFM)
import Module
2015-01-16 14:47:56 +00:00
#endif
2014-04-28 05:36:55 +00:00
#if __GLASGOW_HASKELL__ >= 704
import qualified Data.IntSet as I (IntSet, empty)
#endif
2015-03-05 15:50:06 +00:00
import Bag
import Lexer as L
import Parser
import SrcLoc
import Packages
2015-03-05 15:50:06 +00:00
import Language.Haskell.GhcMod.Types (Expression(..))
2015-08-03 01:09:56 +00:00
import Prelude
----------------------------------------------------------------
----------------------------------------------------------------
--
#if __GLASGOW_HASKELL__ >= 706
type ClsInst = InstEnv.ClsInst
#else
type ClsInst = InstEnv.Instance
#endif
mkTarget :: TargetId -> Bool -> Maybe (SB.StringBuffer, UTCTime) -> Target
#if __GLASGOW_HASKELL__ >= 706
mkTarget = Target
#else
mkTarget tid allowObjCode = Target tid allowObjCode . (fmap . second) convert
#endif
----------------------------------------------------------------
----------------------------------------------------------------
2013-03-12 13:15:23 +00:00
withStyle :: DynFlags -> PprStyle -> SDoc -> Pretty.Doc
#if __GLASGOW_HASKELL__ >= 706
2013-03-12 13:15:23 +00:00
withStyle = withPprStyleDoc
#else
2013-03-12 13:15:23 +00:00
withStyle _ = withPprStyleDoc
#endif
setLogAction :: DynFlags
-> (DynFlags -> Severity -> SrcSpan -> PprStyle -> SDoc -> IO ())
-> DynFlags
setLogAction df f =
#if __GLASGOW_HASKELL__ >= 706
df { log_action = f }
#else
df { log_action = f df }
#endif
showDocWith :: DynFlags -> Pretty.Mode -> Pretty.Doc -> String
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
-- Pretty.showDocWith disappeard.
-- https://github.com/ghc/ghc/commit/08a3536e4246e323fbcd8040e0b80001950fe9bc
showDocWith dflags mode = Pretty.showDoc mode (pprCols dflags)
#else
showDocWith _ = Pretty.showDocWith
#endif
2012-02-14 07:09:53 +00:00
----------------------------------------------------------------
----------------------------------------------------------------
getSrcSpan :: SrcSpan -> Maybe (Int,Int,Int,Int)
#if __GLASGOW_HASKELL__ >= 702
getSrcSpan (RealSrcSpan spn)
#else
getSrcSpan spn | isGoodSrcSpan spn
#endif
= Just (srcSpanStartLine spn
, srcSpanStartCol spn
, srcSpanEndLine spn
, srcSpanEndCol spn)
getSrcSpan _ = Nothing
getSrcFile :: SrcSpan -> Maybe String
#if __GLASGOW_HASKELL__ >= 702
getSrcFile (RealSrcSpan spn) = Just . unpackFS . srcSpanFile $ spn
#else
getSrcFile spn | isGoodSrcSpan spn = Just . unpackFS . srcSpanFile $ spn
#endif
getSrcFile _ = Nothing
----------------------------------------------------------------
toStringBuffer :: GhcMonad m => [String] -> m StringBuffer
2012-02-14 07:09:53 +00:00
#if __GLASGOW_HASKELL__ >= 702
toStringBuffer = return . stringToStringBuffer . unlines
#else
toStringBuffer = liftIO . stringToStringBuffer . unlines
#endif
----------------------------------------------------------------
fOptions :: [String]
2015-01-16 14:47:56 +00:00
#if __GLASGOW_HASKELL__ >= 710
fOptions = [option | (FlagSpec option _ _ _) <- fFlags]
++ [option | (FlagSpec option _ _ _) <- fWarningFlags]
++ [option | (FlagSpec option _ _ _) <- fLangFlags]
#elif __GLASGOW_HASKELL__ >= 704
2012-06-07 06:56:55 +00:00
fOptions = [option | (option,_,_) <- fFlags]
++ [option | (option,_,_) <- fWarningFlags]
++ [option | (option,_,_) <- fLangFlags]
2014-04-28 05:13:25 +00:00
#else
2012-02-14 07:09:53 +00:00
fOptions = [option | (option,_,_,_) <- fFlags]
++ [option | (option,_,_,_) <- fWarningFlags]
++ [option | (option,_,_,_) <- fLangFlags]
2012-02-14 07:09:53 +00:00
#endif
----------------------------------------------------------------
----------------------------------------------------------------
fileModSummary :: GhcMonad m => FilePath -> m ModSummary
fileModSummary file' = do
2014-04-27 12:26:03 +00:00
mss <- getModuleGraph
file <- liftIO $ canonicalizePath file'
[ms] <- liftIO $ flip filterM mss $ \m ->
(Just file==) <$> canonicalizePath `traverse` ml_hs_file (ms_location m)
2014-04-27 12:26:03 +00:00
return ms
withContext :: GhcMonad m => m a -> m a
2014-04-27 12:26:03 +00:00
withContext action = gbracket setup teardown body
where
setup = getContext
2014-04-28 00:28:57 +00:00
teardown = setCtx
2014-04-27 12:26:03 +00:00
body _ = do
2014-04-28 00:00:03 +00:00
topImports >>= setCtx
2014-04-27 12:26:03 +00:00
action
topImports = do
mss <- getModuleGraph
mns <- map modName <$> filterM isTop mss
let ii = map IIModule mns
2014-04-28 02:26:06 +00:00
#if __GLASGOW_HASKELL__ >= 704
return ii
2014-04-28 02:26:06 +00:00
#else
return (ii,[])
2014-04-28 02:26:06 +00:00
#endif
2014-04-28 00:00:03 +00:00
isTop mos = lookupMod mos ||> returnFalse
lookupMod mos = lookupModule (ms_mod_name mos) Nothing >> return True
returnFalse = return False
#if __GLASGOW_HASKELL__ >= 706
modName = moduleName . ms_mod
2014-04-28 00:00:03 +00:00
setCtx = setContext
2014-04-27 12:26:03 +00:00
#elif __GLASGOW_HASKELL__ >= 704
modName = ms_mod
2014-04-28 00:00:03 +00:00
setCtx = setContext
2012-02-14 07:09:53 +00:00
#else
2014-04-28 00:00:03 +00:00
modName = ms_mod
2014-04-28 02:26:06 +00:00
setCtx = uncurry setContext
2012-02-14 07:09:53 +00:00
#endif
-- | Try the left action, if an IOException occurs try the right action.
(||>) :: ExceptionMonad m => m a -> m a -> m a
x ||> y = x `gcatch` (\(_ :: IOException) -> y)
showSeverityCaption :: Severity -> String
#if __GLASGOW_HASKELL__ >= 706
showSeverityCaption SevWarning = "Warning: "
showSeverityCaption _ = ""
#else
showSeverityCaption = const ""
#endif
----------------------------------------------------------------
----------------------------------------------------------------
setCabalPkg :: DynFlags -> DynFlags
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
setCabalPkg dflag = gopt_set dflag Opt_BuildingCabalPackage
#else
setCabalPkg dflag = dopt_set dflag Opt_BuildingCabalPackage
#endif
----------------------------------------------------------------
2014-04-23 01:41:28 +00:00
setHideAllPackages :: DynFlags -> DynFlags
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2014-04-26 04:21:22 +00:00
setHideAllPackages df = gopt_set df Opt_HideAllPackages
2013-07-14 08:07:30 +00:00
#else
2014-04-26 04:21:22 +00:00
setHideAllPackages df = dopt_set df Opt_HideAllPackages
2013-07-14 08:07:30 +00:00
#endif
2014-04-23 01:41:28 +00:00
2014-04-26 04:21:22 +00:00
----------------------------------------------------------------
setDumpSplices :: DynFlags -> DynFlags
setDumpSplices dflag = dopt_set dflag Opt_D_dump_splices
isDumpSplices :: DynFlags -> Bool
isDumpSplices dflag = dopt Opt_D_dump_splices dflag
----------------------------------------------------------------
setDeferTypeErrors :: DynFlags -> DynFlags
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2014-04-26 04:21:22 +00:00
setDeferTypeErrors dflag = gopt_set dflag Opt_DeferTypeErrors
#elif __GLASGOW_HASKELL__ >= 706
setDeferTypeErrors dflag = dopt_set dflag Opt_DeferTypeErrors
#else
setDeferTypeErrors = id
#endif
2014-06-09 08:30:33 +00:00
setWarnTypedHoles :: DynFlags -> DynFlags
#if __GLASGOW_HASKELL__ >= 708
setWarnTypedHoles dflag = wopt_set dflag Opt_WarnTypedHoles
#else
setWarnTypedHoles = id
2014-04-26 04:21:22 +00:00
#endif
----------------------------------------------------------------
----------------------------------------------------------------
class HasType a where
getType :: GhcMonad m => TypecheckedModule -> a -> m (Maybe (SrcSpan, Type))
instance HasType (LHsBind Id) where
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
getType _ (L spn FunBind{fun_matches = m}) = return $ Just (spn, typ)
where in_tys = mg_arg_tys m
out_typ = mg_res_ty m
typ = mkFunTys in_tys out_typ
2013-07-14 08:07:30 +00:00
#else
getType _ (L spn FunBind{fun_matches = MatchGroup _ typ}) = return $ Just (spn, typ)
2013-07-14 08:07:30 +00:00
#endif
getType _ _ = return Nothing
----------------------------------------------------------------
----------------------------------------------------------------
-- from ghc/InteractiveUI.hs
filterOutChildren :: (a -> TyThing) -> [a] -> [a]
filterOutChildren get_thing xs
= [x | x <- xs, not (getName (get_thing x) `elemNameSet` implicits)]
where
implicits = mkNameSet [getName t | x <- xs, t <- implicitTyThings (get_thing x)]
2015-07-04 14:49:48 +00:00
infoThing :: GhcMonad m => (FilePath -> FilePath) -> Expression -> m SDoc
infoThing m (Expression str) = do
names <- parseName str
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
mb_stuffs <- mapM (getInfo False) names
let filtered = filterOutChildren (\(t,_f,_i,_fam) -> t) (catMaybes mb_stuffs)
2013-07-14 08:07:30 +00:00
#else
mb_stuffs <- mapM getInfo names
let filtered = filterOutChildren (\(t,_f,_i) -> t) (catMaybes mb_stuffs)
#endif
2015-07-04 14:49:48 +00:00
return $ vcat (intersperse (text "") $ map (pprInfo m False) filtered)
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2015-07-04 14:49:48 +00:00
pprInfo :: (FilePath -> FilePath) -> Bool -> (TyThing, GHC.Fixity, [ClsInst], [FamInst]) -> SDoc
pprInfo m _ (thing, fixity, insts, famInsts)
= pprTyThingInContextLoc' thing
$$ show_fixity fixity
$$ InstEnv.pprInstances insts
$$ pprFamInsts famInsts
2013-07-14 08:07:30 +00:00
#else
2015-07-04 14:49:48 +00:00
pprInfo :: (FilePath -> FilePath) -> PrintExplicitForalls -> (TyThing, GHC.Fixity, [ClsInst]) -> SDoc
pprInfo m pefas (thing, fixity, insts)
= pprTyThingInContextLoc' pefas thing
$$ show_fixity fixity
$$ vcat (map pprInstance insts)
2015-07-04 14:49:48 +00:00
#endif
where
show_fixity fx
| fx == defaultFixity = Outputable.empty
| otherwise = ppr fx <+> ppr (getName thing)
2015-07-04 14:49:48 +00:00
#if __GLASGOW_HASKELL__ >= 708
pprTyThingInContextLoc' thing' = hang (pprTyThingInContext thing') 2
(char '\t' <> ptext (sLit "--") <+> loc)
where loc = ptext (sLit "Defined") <+> pprNameDefnLoc' (getName thing')
#else
pprTyThingInContextLoc' pefas thing' = hang (pprTyThingInContext pefas thing') 2
(char '\t' <> ptext (sLit "--") <+> loc)
where loc = ptext (sLit "Defined") <+> pprNameDefnLoc' (getName thing')
#endif
2015-07-04 14:49:48 +00:00
pprNameDefnLoc' name
= case Name.nameSrcLoc name of
RealSrcLoc s -> ptext (sLit "at") <+> ppr (subst s)
UnhelpfulLoc s
| Name.isInternalName name || Name.isSystemName name
-> ptext (sLit "at") <+> ftext s
| otherwise
-> ptext (sLit "in") <+> quotes (ppr (nameModule name))
where subst s = mkRealSrcLoc (realFP s) (srcLocLine s) (srcLocCol s)
realFP = mkFastString . m . unpackFS . srcLocFile
2013-11-12 23:44:34 +00:00
2013-11-19 03:28:59 +00:00
----------------------------------------------------------------
----------------------------------------------------------------
errorMsgSpan :: ErrMsg -> SrcSpan
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2013-11-19 03:28:59 +00:00
errorMsgSpan = errMsgSpan
#else
errorMsgSpan = head . errMsgSpans
#endif
2013-11-19 03:35:42 +00:00
typeForUser :: Type -> SDoc
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2013-11-19 03:35:42 +00:00
typeForUser = pprTypeForUser
#else
typeForUser = pprTypeForUser False
#endif
2013-11-19 03:54:08 +00:00
nameForUser :: Name -> SDoc
nameForUser = pprOccName . getOccName
occNameForUser :: OccName -> SDoc
occNameForUser = pprOccName
2013-11-19 03:54:08 +00:00
deSugar :: TypecheckedModule -> LHsExpr Id -> HscEnv
2014-03-27 07:02:16 +00:00
-> IO (Maybe CoreExpr)
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2014-01-08 00:55:06 +00:00
deSugar _ e hs_env = snd <$> deSugarExpr hs_env e
2013-11-19 03:54:08 +00:00
#else
deSugar tcm e hs_env = snd <$> deSugarExpr hs_env modu rn_env ty_env e
where
modu = ms_mod $ pm_mod_summary $ tm_parsed_module tcm
tcgEnv = fst $ tm_internals_ tcm
rn_env = tcg_rdr_env tcgEnv
ty_env = tcg_type_env tcgEnv
#endif
2014-02-06 12:34:40 +00:00
----------------------------------------------------------------
----------------------------------------------------------------
2014-02-06 13:09:00 +00:00
data GapThing = GtA Type | GtT TyCon | GtN
2014-02-06 12:34:40 +00:00
fromTyThing :: TyThing -> GapThing
2014-02-06 13:09:00 +00:00
fromTyThing (AnId i) = GtA $ varType i
2014-04-28 05:04:18 +00:00
#if __GLASGOW_HASKELL__ >= 708
2014-02-06 13:09:00 +00:00
fromTyThing (AConLike (RealDataCon d)) = GtA $ dataConRepType d
fromTyThing (AConLike (PatSynCon p)) = GtA $ patSynType p
#else
2014-02-06 13:09:00 +00:00
fromTyThing (ADataCon d) = GtA $ dataConRepType d
#endif
fromTyThing (ATyCon t) = GtT t
fromTyThing _ = GtN
2014-04-28 05:36:55 +00:00
----------------------------------------------------------------
----------------------------------------------------------------
#if __GLASGOW_HASKELL__ >= 704
type WarnFlags = I.IntSet
emptyWarnFlags :: WarnFlags
emptyWarnFlags = I.empty
#else
type WarnFlags = [WarningFlag]
emptyWarnFlags :: WarnFlags
emptyWarnFlags = []
#endif
2014-07-15 03:29:27 +00:00
----------------------------------------------------------------
----------------------------------------------------------------
2014-07-15 03:35:45 +00:00
#if __GLASGOW_HASKELL__ >= 708
type GLMatch = LMatch RdrName (LHsExpr RdrName)
type GLMatchI = LMatch Id (LHsExpr Id)
2014-07-15 03:35:45 +00:00
#else
type GLMatch = LMatch RdrName
type GLMatchI = LMatch Id
2014-07-15 03:35:45 +00:00
#endif
2014-07-15 05:44:02 +00:00
getClass :: [LInstDecl Name] -> Maybe (Name, SrcSpan)
2015-01-16 14:47:56 +00:00
#if __GLASGOW_HASKELL__ >= 710
-- Instance declarations of sort 'instance F (G a)'
getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsForAllTy _ _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _))))}))] = Just (className, loc)
-- Instance declarations of sort 'instance F G' (no variables)
getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsAppTy (L _ (HsTyVar className)) _))}))] = Just (className, loc)
#elif __GLASGOW_HASKELL__ >= 708
2014-07-15 05:44:02 +00:00
-- Instance declarations of sort 'instance F (G a)'
getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _))))}))] = Just (className, loc)
-- Instance declarations of sort 'instance F G' (no variables)
getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsAppTy (L _ (HsTyVar className)) _))}))] = Just (className, loc)
#elif __GLASGOW_HASKELL__ >= 706
getClass [L loc (ClsInstD (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _)))) _ _ _)] = Just (className, loc)
getClass[L loc (ClsInstD (L _ (HsAppTy (L _ (HsTyVar className)) _)) _ _ _)] = Just (className, loc)
#else
getClass [L loc (InstDecl (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _)))) _ _ _)] = Just (className, loc)
getClass [L loc (InstDecl (L _ (HsAppTy (L _ (HsTyVar className)) _)) _ _ _)] = Just (className, loc)
#endif
getClass _ = Nothing
#if __GLASGOW_HASKELL__ < 706
2014-07-15 06:13:06 +00:00
occName :: RdrName -> OccName
2014-07-15 05:44:02 +00:00
occName = rdrNameOcc
#endif
2014-07-18 02:09:11 +00:00
----------------------------------------------------------------
2015-01-16 14:47:56 +00:00
#if __GLASGOW_HASKELL__ < 710
-- Copied from ghc/InteractiveUI.hs
allExposedPackageConfigs :: DynFlags -> [PackageConfig]
allExposedPackageConfigs df = filter exposed $ eltsUFM $ pkgIdMap $ pkgState df
allExposedModules :: DynFlags -> [ModuleName]
allExposedModules df = concat $ map exposedModules $ allExposedPackageConfigs df
listVisibleModuleNames :: DynFlags -> [ModuleName]
listVisibleModuleNames = allExposedModules
#endif
lookupModulePackageInAllPackages ::
DynFlags -> ModuleName -> [String]
lookupModulePackageInAllPackages df mn =
#if __GLASGOW_HASKELL__ >= 710
unpackSPId . sourcePackageId . snd <$> lookupModuleInAllPackages df mn
where
unpackSPId (SourcePackageId fs) = unpackFS fs
#else
unpackPId . sourcePackageId . fst <$> lookupModuleInAllPackages df mn
where
unpackPId pid = packageIdString $ mkPackageId pid
-- n ++ "-" ++ showVersion v
#endif
2015-01-16 14:47:56 +00:00
listVisibleModules :: DynFlags -> [GHC.Module]
listVisibleModules df = let
#if __GLASGOW_HASKELL__ >= 710
modNames = listVisibleModuleNames df
mods = [ m | mn <- modNames, (m, _) <- lookupModuleInAllPackages df mn ]
#else
pkgCfgs = allExposedPackageConfigs df
mods = [ mkModule pid modname | p <- pkgCfgs
, let pid = packageConfigId p
, modname <- exposedModules p ]
#endif
in mods
isSynTyCon :: TyCon -> Bool
#if __GLASGOW_HASKELL__ >= 710
isSynTyCon = GHC.isTypeSynonymTyCon
#else
isSynTyCon = GHC.isSynTyCon
#endif
2015-03-05 15:50:06 +00:00
parseModuleHeader
:: String -- ^ Haskell module source text (full Unicode is supported)
-> DynFlags
-> FilePath -- ^ the filename (for source locations)
-> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))
parseModuleHeader str dflags filename =
let
loc = mkRealSrcLoc (mkFastString filename) 1 1
buf = stringToStringBuffer str
in
case L.unP Parser.parseHeader (mkPState dflags buf loc) of
PFailed sp err ->
#if __GLASGOW_HASKELL__ >= 706
Left (unitBag (mkPlainErrMsg dflags sp err))
#else
Left (unitBag (mkPlainErrMsg sp err))
#endif
POk pst rdr_module ->
let (warns,_) = getMessages pst in
Right (warns, rdr_module)