{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}
module GHC.Types.Name.Reader (
RdrName(..),
mkRdrUnqual, mkRdrQual,
mkUnqual, mkVarUnqual, mkQual, mkOrig,
nameRdrName, getRdrName,
rdrNameOcc, rdrNameSpace,
demoteRdrName, demoteRdrNameTcCls, demoteRdrNameTv,
promoteRdrName,
isRdrDataCon, isRdrTyVar, isRdrTc, isQual, isQual_maybe, isUnqual,
isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName,
WithUserRdr(..), noUserRdr, unLocWithUserRdr,
LocalRdrEnv, emptyLocalRdrEnv, extendLocalRdrEnv, extendLocalRdrEnvList,
lookupLocalRdrEnv, lookupLocalRdrOcc,
elemLocalRdrEnv, inLocalRdrEnvScope,
localRdrEnvElts, minusLocalRdrEnv, minusLocalRdrEnvList,
GlobalRdrEnvX, GlobalRdrEnv, IfGlobalRdrEnv,
emptyGlobalRdrEnv, mkGlobalRdrEnv, plusGlobalRdrEnv,
extendGlobalRdrEnv, greOccName,
pprGlobalRdrEnv, globalRdrEnvElts, globalRdrEnvLocal,
FieldsOrSelectors(..), filterFieldGREs, allowGRE,
LookupGRE(..), lookupGRE,
WhichGREs(.., AllRelevantGREs, RelevantGREsFOS),
greIsRelevant,
lookupGRE_Name,
lookupGRE_FieldLabel,
getGRE_NameQualifier_maybes,
transformGREs, pickGREs, pickGREsModExp,
availFromGRE,
greRdrNames, greSrcSpan, greQualModName,
gresToAvailInfo,
greDefinitionModule, greDefinitionSrcSpan,
greFieldLabel_maybe,
GlobalRdrEltX(..), GlobalRdrElt, IfGlobalRdrElt, FieldGlobalRdrElt,
greName, greNameSpace, greParent, greInfo,
plusGRE, insertGRE,
forceGlobalRdrEnv, hydrateGlobalRdrEnv,
isLocalGRE, isImportedGRE, isRecFldGRE,
fieldGREInfo,
isDuplicateRecFldGRE, isNoFieldSelectorGRE, isFieldSelectorGRE,
unQualOK, qualSpecOK, unQualSpecOK,
pprNameProvenance,
mkGRE, mkExactGRE, mkLocalGRE, mkLocalVanillaGRE, mkLocalTyConGRE,
mkLocalConLikeGRE, mkLocalFieldGREs,
gresToNameSet,
greClashesWith, shadowNames,
ConLikeName(..),
GREInfo(..), RecFieldInfo(..),
plusGREInfo,
recFieldConLike_maybe, recFieldInfo_maybe,
fieldGRE_maybe, fieldGRELabel,
Parent(..), ParentGRE(..), greParent_maybe,
mkParent, availParent,
ImportSpec(..), ImpDeclSpec(..), ImpItemSpec(..),
importSpecLoc, importSpecModule, isExplicitItem, bestImport,
opIsAt
) where
import GHC.Prelude
import GHC.Data.Bag
import GHC.Data.FastString
import GHC.Data.Maybe
import GHC.Types.Avail
import GHC.Types.Basic
import GHC.Types.GREInfo
import GHC.Types.FieldLabel
import GHC.Types.Name
import GHC.Types.Name.Env
import GHC.Types.Name.Set
import GHC.Types.PkgQual
import GHC.Types.SrcLoc as SrcLoc
import GHC.Types.Unique
import GHC.Types.Unique.FM
import GHC.Types.Unique.Set
import GHC.Builtin.Uniques ( isFldNSUnique )
import GHC.Unit.Module
import GHC.Utils.Misc as Utils
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Utils.Binary
import Control.DeepSeq
import Control.Monad ( guard )
import Data.Data
import Data.List ( sort )
import qualified Data.List.NonEmpty as NE
import qualified Data.Map.Strict as Map
import qualified Data.Semigroup as S
import System.IO.Unsafe ( unsafePerformIO )
data RdrName
= Unqual OccName
| Qual ModuleName OccName
| Orig Module OccName
| Exact Name
deriving Typeable RdrName
Typeable RdrName =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RdrName -> c RdrName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RdrName)
-> (RdrName -> Constr)
-> (RdrName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RdrName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName))
-> ((forall b. Data b => b -> b) -> RdrName -> RdrName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r)
-> (forall u. (forall d. Data d => d -> u) -> RdrName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RdrName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName)
-> Data RdrName
RdrName -> Constr
RdrName -> DataType
(forall b. Data b => b -> b) -> RdrName -> RdrName
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RdrName -> u
forall u. (forall d. Data d => d -> u) -> RdrName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RdrName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RdrName -> c RdrName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RdrName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RdrName -> c RdrName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RdrName -> c RdrName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RdrName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RdrName
$ctoConstr :: RdrName -> Constr
toConstr :: RdrName -> Constr
$cdataTypeOf :: RdrName -> DataType
dataTypeOf :: RdrName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RdrName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RdrName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName)
$cgmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName
gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RdrName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RdrName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RdrName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RdrName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RdrName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RdrName -> m RdrName
Data
instance HasOccName RdrName where
occName :: RdrName -> OccName
occName = RdrName -> OccName
rdrNameOcc
rdrNameOcc :: RdrName -> OccName
rdrNameOcc :: RdrName -> OccName
rdrNameOcc (Qual ModuleName
_ OccName
occ) = OccName
occ
rdrNameOcc (Unqual OccName
occ) = OccName
occ
rdrNameOcc (Orig Module
_ OccName
occ) = OccName
occ
rdrNameOcc (Exact Name
name) = Name -> OccName
nameOccName Name
name
rdrNameSpace :: RdrName -> NameSpace
rdrNameSpace :: RdrName -> NameSpace
rdrNameSpace = OccName -> NameSpace
occNameSpace (OccName -> NameSpace)
-> (RdrName -> OccName) -> RdrName -> NameSpace
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RdrName -> OccName
rdrNameOcc
demoteRdrName :: RdrName -> Maybe RdrName
demoteRdrName :: RdrName -> Maybe RdrName
demoteRdrName (Unqual OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OccName -> RdrName
Unqual (OccName -> Maybe OccName
demoteOccName OccName
occ)
demoteRdrName (Qual ModuleName
m OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModuleName -> OccName -> RdrName
Qual ModuleName
m) (OccName -> Maybe OccName
demoteOccName OccName
occ)
demoteRdrName (Orig Module
_ OccName
_) = Maybe RdrName
forall a. Maybe a
Nothing
demoteRdrName (Exact Name
_) = Maybe RdrName
forall a. Maybe a
Nothing
demoteRdrNameTcCls :: RdrName -> Maybe RdrName
demoteRdrNameTcCls :: RdrName -> Maybe RdrName
demoteRdrNameTcCls (Unqual OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OccName -> RdrName
Unqual (OccName -> Maybe OccName
demoteOccTcClsName OccName
occ)
demoteRdrNameTcCls (Qual ModuleName
m OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModuleName -> OccName -> RdrName
Qual ModuleName
m) (OccName -> Maybe OccName
demoteOccTcClsName OccName
occ)
demoteRdrNameTcCls (Orig Module
_ OccName
_) = Maybe RdrName
forall a. Maybe a
Nothing
demoteRdrNameTcCls (Exact Name
_) = Maybe RdrName
forall a. Maybe a
Nothing
demoteRdrNameTv :: RdrName -> Maybe RdrName
demoteRdrNameTv :: RdrName -> Maybe RdrName
demoteRdrNameTv (Unqual OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OccName -> RdrName
Unqual (OccName -> Maybe OccName
demoteOccTvName OccName
occ)
demoteRdrNameTv (Qual ModuleName
m OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModuleName -> OccName -> RdrName
Qual ModuleName
m) (OccName -> Maybe OccName
demoteOccTvName OccName
occ)
demoteRdrNameTv (Orig Module
_ OccName
_) = Maybe RdrName
forall a. Maybe a
Nothing
demoteRdrNameTv (Exact Name
_) = Maybe RdrName
forall a. Maybe a
Nothing
promoteRdrName :: RdrName -> Maybe RdrName
promoteRdrName :: RdrName -> Maybe RdrName
promoteRdrName (Unqual OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap OccName -> RdrName
Unqual (OccName -> Maybe OccName
promoteOccName OccName
occ)
promoteRdrName (Qual ModuleName
m OccName
occ) = (OccName -> RdrName) -> Maybe OccName -> Maybe RdrName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModuleName -> OccName -> RdrName
Qual ModuleName
m) (OccName -> Maybe OccName
promoteOccName OccName
occ)
promoteRdrName (Orig Module
_ OccName
_) = Maybe RdrName
forall a. Maybe a
Nothing
promoteRdrName (Exact Name
_) = Maybe RdrName
forall a. Maybe a
Nothing
mkRdrUnqual :: OccName -> RdrName
mkRdrUnqual :: OccName -> RdrName
mkRdrUnqual OccName
occ = OccName -> RdrName
Unqual OccName
occ
mkRdrQual :: ModuleName -> OccName -> RdrName
mkRdrQual :: ModuleName -> OccName -> RdrName
mkRdrQual ModuleName
mod OccName
occ = ModuleName -> OccName -> RdrName
Qual ModuleName
mod OccName
occ
mkOrig :: Module -> OccName -> RdrName
mkOrig :: Module -> OccName -> RdrName
mkOrig Module
mod OccName
occ = Module -> OccName -> RdrName
Orig Module
mod OccName
occ
mkUnqual :: NameSpace -> FastString -> RdrName
mkUnqual :: NameSpace -> FastString -> RdrName
mkUnqual NameSpace
sp FastString
n = OccName -> RdrName
Unqual (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
sp FastString
n)
mkVarUnqual :: FastString -> RdrName
mkVarUnqual :: FastString -> RdrName
mkVarUnqual FastString
n = OccName -> RdrName
Unqual (FastString -> OccName
mkVarOccFS FastString
n)
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
mkQual NameSpace
sp (FastString
m, FastString
n) = ModuleName -> OccName -> RdrName
Qual (FastString -> ModuleName
mkModuleNameFS FastString
m) (NameSpace -> FastString -> OccName
mkOccNameFS NameSpace
sp FastString
n)
getRdrName :: NamedThing thing => thing -> RdrName
getRdrName :: forall thing. NamedThing thing => thing -> RdrName
getRdrName thing
name = Name -> RdrName
nameRdrName (thing -> Name
forall a. NamedThing a => a -> Name
getName thing
name)
nameRdrName :: Name -> RdrName
nameRdrName :: Name -> RdrName
nameRdrName Name
name = Name -> RdrName
Exact Name
name
nukeExact :: Name -> RdrName
nukeExact :: Name -> RdrName
nukeExact Name
n
| Name -> Bool
isExternalName Name
n = Module -> OccName -> RdrName
Orig (HasDebugCallStack => Name -> Module
Name -> Module
nameModule Name
n) (Name -> OccName
nameOccName Name
n)
| Bool
otherwise = OccName -> RdrName
Unqual (Name -> OccName
nameOccName Name
n)
isRdrDataCon :: RdrName -> Bool
isRdrTyVar :: RdrName -> Bool
isRdrTc :: RdrName -> Bool
isRdrDataCon :: RdrName -> Bool
isRdrDataCon RdrName
rn = OccName -> Bool
isDataOcc (RdrName -> OccName
rdrNameOcc RdrName
rn)
isRdrTyVar :: RdrName -> Bool
isRdrTyVar RdrName
rn = OccName -> Bool
isTvOcc (RdrName -> OccName
rdrNameOcc RdrName
rn)
isRdrTc :: RdrName -> Bool
isRdrTc RdrName
rn = OccName -> Bool
isTcOcc (RdrName -> OccName
rdrNameOcc RdrName
rn)
isSrcRdrName :: RdrName -> Bool
isSrcRdrName :: RdrName -> Bool
isSrcRdrName (Unqual OccName
_) = Bool
True
isSrcRdrName (Qual ModuleName
_ OccName
_) = Bool
True
isSrcRdrName RdrName
_ = Bool
False
isUnqual :: RdrName -> Bool
isUnqual :: RdrName -> Bool
isUnqual (Unqual OccName
_) = Bool
True
isUnqual RdrName
_ = Bool
False
isQual :: RdrName -> Bool
isQual :: RdrName -> Bool
isQual (Qual ModuleName
_ OccName
_) = Bool
True
isQual RdrName
_ = Bool
False
isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
isQual_maybe (Qual ModuleName
m OccName
n) = (ModuleName, OccName) -> Maybe (ModuleName, OccName)
forall a. a -> Maybe a
Just (ModuleName
m,OccName
n)
isQual_maybe RdrName
_ = Maybe (ModuleName, OccName)
forall a. Maybe a
Nothing
isOrig :: RdrName -> Bool
isOrig :: RdrName -> Bool
isOrig (Orig Module
_ OccName
_) = Bool
True
isOrig RdrName
_ = Bool
False
isOrig_maybe :: RdrName -> Maybe (Module, OccName)
isOrig_maybe :: RdrName -> Maybe (Module, OccName)
isOrig_maybe (Orig Module
m OccName
n) = (Module, OccName) -> Maybe (Module, OccName)
forall a. a -> Maybe a
Just (Module
m,OccName
n)
isOrig_maybe RdrName
_ = Maybe (Module, OccName)
forall a. Maybe a
Nothing
isExact :: RdrName -> Bool
isExact :: RdrName -> Bool
isExact (Exact Name
_) = Bool
True
isExact RdrName
_ = Bool
False
isExact_maybe :: RdrName -> Maybe Name
isExact_maybe :: RdrName -> Maybe Name
isExact_maybe (Exact Name
n) = Name -> Maybe Name
forall a. a -> Maybe a
Just Name
n
isExact_maybe RdrName
_ = Maybe Name
forall a. Maybe a
Nothing
instance Outputable RdrName where
ppr :: RdrName -> SDoc
ppr (Exact Name
name) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name
ppr (Unqual OccName
occ) = OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ
ppr (Qual ModuleName
mod OccName
occ) = ModuleName -> SDoc
forall a. Outputable a => a -> SDoc
ppr ModuleName
mod SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
forall doc. IsLine doc => doc
dot SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ
ppr (Orig Module
mod OccName
occ) = (PprStyle -> SDoc) -> SDoc
getPprStyle (\PprStyle
sty -> PprStyle -> Module -> Maybe ModuleName -> OccName -> SDoc
pprModulePrefix PprStyle
sty Module
mod Maybe ModuleName
forall a. Maybe a
Nothing OccName
occ SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ)
instance OutputableBndr RdrName where
pprBndr :: BindingSite -> RdrName -> SDoc
pprBndr BindingSite
_ RdrName
n
| OccName -> Bool
isTvOcc (RdrName -> OccName
rdrNameOcc RdrName
n) = Char -> SDoc
forall doc. IsLine doc => Char -> doc
char Char
'@' SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
n
| Bool
otherwise = RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
n
pprInfixOcc :: RdrName -> SDoc
pprInfixOcc RdrName
rdr = Bool -> SDoc -> SDoc
pprInfixVar (OccName -> Bool
isSymOcc (RdrName -> OccName
rdrNameOcc RdrName
rdr)) (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
rdr)
pprPrefixOcc :: RdrName -> SDoc
pprPrefixOcc RdrName
rdr
| Just Name
name <- RdrName -> Maybe Name
isExact_maybe RdrName
rdr = Name -> SDoc
forall a. (Outputable a, NamedThing a) => a -> SDoc
pprPrefixName Name
name
| Bool
otherwise = Bool -> SDoc -> SDoc
pprPrefixVar (OccName -> Bool
isSymOcc (RdrName -> OccName
rdrNameOcc RdrName
rdr)) (RdrName -> SDoc
forall a. Outputable a => a -> SDoc
ppr RdrName
rdr)
instance Eq RdrName where
(Exact Name
n1) == :: RdrName -> RdrName -> Bool
== (Exact Name
n2) = Name
n1Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
==Name
n2
(Exact Name
n1) == r2 :: RdrName
r2@(Orig Module
_ OccName
_) = Name -> RdrName
nukeExact Name
n1 RdrName -> RdrName -> Bool
forall a. Eq a => a -> a -> Bool
== RdrName
r2
r1 :: RdrName
r1@(Orig Module
_ OccName
_) == (Exact Name
n2) = RdrName
r1 RdrName -> RdrName -> Bool
forall a. Eq a => a -> a -> Bool
== Name -> RdrName
nukeExact Name
n2
(Orig Module
m1 OccName
o1) == (Orig Module
m2 OccName
o2) = Module
m1Module -> Module -> Bool
forall a. Eq a => a -> a -> Bool
==Module
m2 Bool -> Bool -> Bool
&& OccName
o1OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
==OccName
o2
(Qual ModuleName
m1 OccName
o1) == (Qual ModuleName
m2 OccName
o2) = ModuleName
m1ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
==ModuleName
m2 Bool -> Bool -> Bool
&& OccName
o1OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
==OccName
o2
(Unqual OccName
o1) == (Unqual OccName
o2) = OccName
o1OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
==OccName
o2
RdrName
_ == RdrName
_ = Bool
False
instance Ord RdrName where
RdrName
a <= :: RdrName -> RdrName -> Bool
<= RdrName
b = case (RdrName
a RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` RdrName
b) of { Ordering
LT -> Bool
True; Ordering
EQ -> Bool
True; Ordering
GT -> Bool
False }
RdrName
a < :: RdrName -> RdrName -> Bool
< RdrName
b = case (RdrName
a RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` RdrName
b) of { Ordering
LT -> Bool
True; Ordering
EQ -> Bool
False; Ordering
GT -> Bool
False }
RdrName
a >= :: RdrName -> RdrName -> Bool
>= RdrName
b = case (RdrName
a RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` RdrName
b) of { Ordering
LT -> Bool
False; Ordering
EQ -> Bool
True; Ordering
GT -> Bool
True }
RdrName
a > :: RdrName -> RdrName -> Bool
> RdrName
b = case (RdrName
a RdrName -> RdrName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` RdrName
b) of { Ordering
LT -> Bool
False; Ordering
EQ -> Bool
False; Ordering
GT -> Bool
True }
compare :: RdrName -> RdrName -> Ordering
compare (Exact Name
n1) (Exact Name
n2) = Name
n1 Name -> Name -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Name
n2
compare (Exact Name
_) RdrName
_ = Ordering
LT
compare (Unqual OccName
_) (Exact Name
_) = Ordering
GT
compare (Unqual OccName
o1) (Unqual OccName
o2) = OccName
o1 OccName -> OccName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` OccName
o2
compare (Unqual OccName
_) RdrName
_ = Ordering
LT
compare (Qual ModuleName
_ OccName
_) (Exact Name
_) = Ordering
GT
compare (Qual ModuleName
_ OccName
_) (Unqual OccName
_) = Ordering
GT
compare (Qual ModuleName
m1 OccName
o1) (Qual ModuleName
m2 OccName
o2) = OccName -> OccName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare OccName
o1 OccName
o2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
S.<> ModuleName -> ModuleName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ModuleName
m1 ModuleName
m2
compare (Qual ModuleName
_ OccName
_) (Orig Module
_ OccName
_) = Ordering
LT
compare (Orig Module
m1 OccName
o1) (Orig Module
m2 OccName
o2) = OccName -> OccName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare OccName
o1 OccName
o2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
S.<> Module -> Module -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Module
m1 Module
m2
compare (Orig Module
_ OccName
_) RdrName
_ = Ordering
GT
data LocalRdrEnv = LRE { LocalRdrEnv -> OccEnv Name
lre_env :: OccEnv Name
, LocalRdrEnv -> NameSet
lre_in_scope :: NameSet }
instance Outputable LocalRdrEnv where
ppr :: LocalRdrEnv -> SDoc
ppr (LRE {lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env, lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns})
= SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"LocalRdrEnv {")
Int
2 ([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"env =" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> (Name -> SDoc) -> OccEnv Name -> SDoc
forall a. (a -> SDoc) -> OccEnv a -> SDoc
pprOccEnv Name -> SDoc
ppr_elt OccEnv Name
env
, String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"in_scope ="
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> UniqFM Name Name -> ([Name] -> SDoc) -> SDoc
forall {k} (key :: k) a. UniqFM key a -> ([a] -> SDoc) -> SDoc
pprUFM (NameSet -> UniqFM Name Name
forall a. UniqSet a -> UniqFM a a
getUniqSet NameSet
ns) (SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
braces (SDoc -> SDoc) -> ([Name] -> SDoc) -> [Name] -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name -> SDoc) -> [Name] -> SDoc
forall a. (a -> SDoc) -> [a] -> SDoc
pprWithCommas Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr)
] SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Char -> SDoc
forall doc. IsLine doc => Char -> doc
char Char
'}')
where
ppr_elt :: Name -> SDoc
ppr_elt Name
name = SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
parens (OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Name -> OccName
nameOccName Name
name)) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name
emptyLocalRdrEnv :: LocalRdrEnv
emptyLocalRdrEnv :: LocalRdrEnv
emptyLocalRdrEnv = LRE { lre_env :: OccEnv Name
lre_env = OccEnv Name
forall a. OccEnv a
emptyOccEnv
, lre_in_scope :: NameSet
lre_in_scope = NameSet
emptyNameSet }
extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
extendLocalRdrEnv lre :: LocalRdrEnv
lre@(LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env, lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns }) Name
name
= LocalRdrEnv
lre { lre_env = extendOccEnv env (nameOccName name) name
, lre_in_scope = extendNameSet ns name }
extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
extendLocalRdrEnvList lre :: LocalRdrEnv
lre@(LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env, lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns }) [Name]
names
= LocalRdrEnv
lre { lre_env = extendOccEnvList env [(nameOccName n, n) | n <- names]
, lre_in_scope = extendNameSetList ns names }
lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
lookupLocalRdrEnv (LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env, lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns }) RdrName
rdr
| Unqual OccName
occ <- RdrName
rdr
= OccEnv Name -> OccName -> Maybe Name
forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv OccEnv Name
env OccName
occ
| Exact Name
name <- RdrName
rdr
, Name
name Name -> NameSet -> Bool
`elemNameSet` NameSet
ns
= Name -> Maybe Name
forall a. a -> Maybe a
Just Name
name
| Bool
otherwise
= Maybe Name
forall a. Maybe a
Nothing
lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
lookupLocalRdrOcc (LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env }) OccName
occ = OccEnv Name -> OccName -> Maybe Name
forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv OccEnv Name
env OccName
occ
elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
elemLocalRdrEnv RdrName
rdr_name (LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env, lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns })
= case RdrName
rdr_name of
Unqual OccName
occ -> OccName
occ OccName -> OccEnv Name -> Bool
forall a. OccName -> OccEnv a -> Bool
`elemOccEnv` OccEnv Name
env
Exact Name
name -> Name
name Name -> NameSet -> Bool
`elemNameSet` NameSet
ns
Qual {} -> Bool
False
Orig {} -> Bool
False
localRdrEnvElts :: LocalRdrEnv -> [Name]
localRdrEnvElts :: LocalRdrEnv -> [Name]
localRdrEnvElts (LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env }) = OccEnv Name -> [Name]
forall a. OccEnv a -> [a]
nonDetOccEnvElts OccEnv Name
env
inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool
inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool
inLocalRdrEnvScope Name
name (LRE { lre_in_scope :: LocalRdrEnv -> NameSet
lre_in_scope = NameSet
ns }) = Name
name Name -> NameSet -> Bool
`elemNameSet` NameSet
ns
minusLocalRdrEnv :: LocalRdrEnv -> OccEnv a -> LocalRdrEnv
minusLocalRdrEnv :: forall a. LocalRdrEnv -> OccEnv a -> LocalRdrEnv
minusLocalRdrEnv lre :: LocalRdrEnv
lre@(LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env }) OccEnv a
occs
= LocalRdrEnv
lre { lre_env = minusOccEnv env occs }
minusLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv
minusLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv
minusLocalRdrEnvList lre :: LocalRdrEnv
lre@(LRE { lre_env :: LocalRdrEnv -> OccEnv Name
lre_env = OccEnv Name
env }) [OccName]
occs
= LocalRdrEnv
lre { lre_env = delListFromOccEnv env occs }
type GlobalRdrEnv = GlobalRdrEnvX GREInfo
type IfGlobalRdrEnv = GlobalRdrEnvX ()
type GlobalRdrEnvX info = OccEnv [GlobalRdrEltX info]
type GlobalRdrElt = GlobalRdrEltX GREInfo
type IfGlobalRdrElt = GlobalRdrEltX ()
data GlobalRdrEltX info
= GRE { forall info. GlobalRdrEltX info -> Name
gre_name :: !Name
, forall info. GlobalRdrEltX info -> Parent
gre_par :: !Parent
, forall info. GlobalRdrEltX info -> Bool
gre_lcl :: !Bool
, forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp :: !(Bag ImportSpec)
, forall info. GlobalRdrEltX info -> info
gre_info :: info
} deriving (Typeable (GlobalRdrEltX info)
Typeable (GlobalRdrEltX info) =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GlobalRdrEltX info
-> c (GlobalRdrEltX info))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info))
-> (GlobalRdrEltX info -> Constr)
-> (GlobalRdrEltX info -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GlobalRdrEltX info)))
-> ((forall b. Data b => b -> b)
-> GlobalRdrEltX info -> GlobalRdrEltX info)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r)
-> (forall u.
(forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info))
-> Data (GlobalRdrEltX info)
GlobalRdrEltX info -> Constr
GlobalRdrEltX info -> DataType
(forall b. Data b => b -> b)
-> GlobalRdrEltX info -> GlobalRdrEltX info
forall info. Data info => Typeable (GlobalRdrEltX info)
forall info. Data info => GlobalRdrEltX info -> Constr
forall info. Data info => GlobalRdrEltX info -> DataType
forall info.
Data info =>
(forall b. Data b => b -> b)
-> GlobalRdrEltX info -> GlobalRdrEltX info
forall info u.
Data info =>
Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u
forall info u.
Data info =>
(forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u]
forall info r r'.
Data info =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
forall info r r'.
Data info =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
forall info (m :: * -> *).
(Data info, Monad m) =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
forall info (m :: * -> *).
(Data info, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
forall info (c :: * -> *).
Data info =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info)
forall info (c :: * -> *).
Data info =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GlobalRdrEltX info
-> c (GlobalRdrEltX info)
forall info (t :: * -> *) (c :: * -> *).
(Data info, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info))
forall info (t :: * -> * -> *) (c :: * -> *).
(Data info, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GlobalRdrEltX info))
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u
forall u. (forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GlobalRdrEltX info
-> c (GlobalRdrEltX info)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GlobalRdrEltX info))
$cgfoldl :: forall info (c :: * -> *).
Data info =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GlobalRdrEltX info
-> c (GlobalRdrEltX info)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GlobalRdrEltX info
-> c (GlobalRdrEltX info)
$cgunfold :: forall info (c :: * -> *).
Data info =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info)
$ctoConstr :: forall info. Data info => GlobalRdrEltX info -> Constr
toConstr :: GlobalRdrEltX info -> Constr
$cdataTypeOf :: forall info. Data info => GlobalRdrEltX info -> DataType
dataTypeOf :: GlobalRdrEltX info -> DataType
$cdataCast1 :: forall info (t :: * -> *) (c :: * -> *).
(Data info, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info))
$cdataCast2 :: forall info (t :: * -> * -> *) (c :: * -> *).
(Data info, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GlobalRdrEltX info))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GlobalRdrEltX info))
$cgmapT :: forall info.
Data info =>
(forall b. Data b => b -> b)
-> GlobalRdrEltX info -> GlobalRdrEltX info
gmapT :: (forall b. Data b => b -> b)
-> GlobalRdrEltX info -> GlobalRdrEltX info
$cgmapQl :: forall info r r'.
Data info =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
$cgmapQr :: forall info r r'.
Data info =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r
$cgmapQ :: forall info u.
Data info =>
(forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u]
$cgmapQi :: forall info u.
Data info =>
Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u
$cgmapM :: forall info (m :: * -> *).
(Data info, Monad m) =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
$cgmapMp :: forall info (m :: * -> *).
(Data info, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
$cgmapMo :: forall info (m :: * -> *).
(Data info, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GlobalRdrEltX info -> m (GlobalRdrEltX info)
Data)
instance NFData a => NFData (GlobalRdrEltX a) where
rnf :: GlobalRdrEltX a -> ()
rnf (GRE Name
name Parent
par Bool
_ Bag ImportSpec
imp a
info) = Name -> ()
forall a. NFData a => a -> ()
rnf Name
name () -> () -> ()
forall a b. a -> b -> b
`seq` Parent -> ()
forall a. NFData a => a -> ()
rnf Parent
par () -> () -> ()
forall a b. a -> b -> b
`seq` Bag ImportSpec -> ()
forall a. NFData a => a -> ()
rnf Bag ImportSpec
imp () -> () -> ()
forall a b. a -> b -> b
`seq` a -> ()
forall a. NFData a => a -> ()
rnf a
info
type FieldGlobalRdrElt = GlobalRdrElt
greName :: GlobalRdrEltX info -> Name
greName :: forall info. GlobalRdrEltX info -> Name
greName = GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
gre_name
greNameSpace :: GlobalRdrEltX info -> NameSpace
greNameSpace :: forall info. GlobalRdrEltX info -> NameSpace
greNameSpace = Name -> NameSpace
nameNameSpace (Name -> NameSpace)
-> (GlobalRdrEltX info -> Name) -> GlobalRdrEltX info -> NameSpace
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName
greParent :: GlobalRdrEltX info -> Parent
greParent :: forall info. GlobalRdrEltX info -> Parent
greParent = GlobalRdrEltX info -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par
greInfo :: GlobalRdrElt -> GREInfo
greInfo :: GlobalRdrElt -> GREInfo
greInfo = GlobalRdrElt -> GREInfo
forall info. GlobalRdrEltX info -> info
gre_info
data Parent = NoParent
| ParentIs { Parent -> Name
par_is :: !Name }
deriving (Parent -> Parent -> Bool
(Parent -> Parent -> Bool)
-> (Parent -> Parent -> Bool) -> Eq Parent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Parent -> Parent -> Bool
== :: Parent -> Parent -> Bool
$c/= :: Parent -> Parent -> Bool
/= :: Parent -> Parent -> Bool
Eq, Typeable Parent
Typeable Parent =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parent -> c Parent)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parent)
-> (Parent -> Constr)
-> (Parent -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parent))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent))
-> ((forall b. Data b => b -> b) -> Parent -> Parent)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parent -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parent -> r)
-> (forall u. (forall d. Data d => d -> u) -> Parent -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Parent -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent)
-> Data Parent
Parent -> Constr
Parent -> DataType
(forall b. Data b => b -> b) -> Parent -> Parent
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Parent -> u
forall u. (forall d. Data d => d -> u) -> Parent -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parent
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parent -> c Parent
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parent)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parent -> c Parent
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parent -> c Parent
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parent
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parent
$ctoConstr :: Parent -> Constr
toConstr :: Parent -> Constr
$cdataTypeOf :: Parent -> DataType
dataTypeOf :: Parent -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parent)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parent)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent)
$cgmapT :: (forall b. Data b => b -> b) -> Parent -> Parent
gmapT :: (forall b. Data b => b -> b) -> Parent -> Parent
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Parent -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Parent -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parent -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parent -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parent -> m Parent
Data)
instance Outputable Parent where
ppr :: Parent -> SDoc
ppr Parent
NoParent = SDoc
forall doc. IsOutput doc => doc
empty
ppr (ParentIs Name
n) = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"parent:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n
instance NFData Parent where
rnf :: Parent -> ()
rnf Parent
NoParent = ()
rnf (ParentIs Name
n) = Name -> ()
forall a. NFData a => a -> ()
rnf Name
n
plusParent :: Parent -> Parent -> Parent
plusParent :: Parent -> Parent -> Parent
plusParent p1 :: Parent
p1@(ParentIs Name
_) Parent
p2 = Parent -> Parent -> Parent
hasParent Parent
p1 Parent
p2
plusParent Parent
p1 p2 :: Parent
p2@(ParentIs Name
_) = Parent -> Parent -> Parent
hasParent Parent
p2 Parent
p1
plusParent Parent
NoParent Parent
NoParent = Parent
NoParent
hasParent :: Parent -> Parent -> Parent
#if defined(DEBUG)
hasParent p NoParent = p
hasParent p p'
| p /= p' = pprPanic "hasParent" (ppr p <+> ppr p')
#endif
hasParent :: Parent -> Parent -> Parent
hasParent Parent
p Parent
_ = Parent
p
mkGRE :: (Name -> Maybe ImportSpec) -> GREInfo -> Parent -> Name -> GlobalRdrElt
mkGRE :: (Name -> Maybe ImportSpec)
-> GREInfo -> Parent -> Name -> GlobalRdrElt
mkGRE Name -> Maybe ImportSpec
prov_fn GREInfo
info Parent
par Name
n =
case Name -> Maybe ImportSpec
prov_fn Name
n of
Maybe ImportSpec
Nothing -> GRE { gre_name :: Name
gre_name = Name
n, gre_par :: Parent
gre_par = Parent
par
, gre_lcl :: Bool
gre_lcl = Bool
True, gre_imp :: Bag ImportSpec
gre_imp = Bag ImportSpec
forall a. Bag a
emptyBag
, gre_info :: GREInfo
gre_info = GREInfo
info }
Just ImportSpec
is -> GRE { gre_name :: Name
gre_name = Name
n, gre_par :: Parent
gre_par = Parent
par
, gre_lcl :: Bool
gre_lcl = Bool
False, gre_imp :: Bag ImportSpec
gre_imp = ImportSpec -> Bag ImportSpec
forall a. a -> Bag a
unitBag ImportSpec
is
, gre_info :: GREInfo
gre_info = GREInfo
info }
mkExactGRE :: Name -> GREInfo -> GlobalRdrElt
mkExactGRE :: Name -> GREInfo -> GlobalRdrElt
mkExactGRE Name
nm GREInfo
info =
GRE { gre_name :: Name
gre_name = Name
nm, gre_par :: Parent
gre_par = Parent
NoParent
, gre_lcl :: Bool
gre_lcl = Bool
False, gre_imp :: Bag ImportSpec
gre_imp = Bag ImportSpec
forall a. Bag a
emptyBag
, gre_info :: GREInfo
gre_info = GREInfo
info }
mkLocalGRE :: GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE :: GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE = (Name -> Maybe ImportSpec)
-> GREInfo -> Parent -> Name -> GlobalRdrElt
mkGRE (Maybe ImportSpec -> Name -> Maybe ImportSpec
forall a b. a -> b -> a
const Maybe ImportSpec
forall a. Maybe a
Nothing)
mkLocalVanillaGRE :: Parent -> Name -> GlobalRdrElt
mkLocalVanillaGRE :: Parent -> Name -> GlobalRdrElt
mkLocalVanillaGRE = GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE GREInfo
Vanilla
mkLocalTyConGRE :: TyConFlavour Name
-> Name
-> GlobalRdrElt
mkLocalTyConGRE :: TyConFlavour Name -> Name -> GlobalRdrElt
mkLocalTyConGRE TyConFlavour Name
flav Name
nm = GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE (TyConFlavour Name -> GREInfo
IAmTyCon TyConFlavour Name
flav) Parent
par Name
nm
where
par :: Parent
par = case TyConFlavour Name -> Maybe Name
forall tc. TyConFlavour tc -> Maybe tc
tyConFlavourAssoc_maybe TyConFlavour Name
flav of
Maybe Name
Nothing -> Parent
NoParent
Just Name
p -> Name -> Parent
ParentIs Name
p
mkLocalConLikeGRE :: Parent -> (ConLikeName, ConInfo) -> GlobalRdrElt
mkLocalConLikeGRE :: Parent -> (ConLikeName, ConInfo) -> GlobalRdrElt
mkLocalConLikeGRE Parent
p (ConLikeName
con_nm, ConInfo
con_info) =
GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE (ConInfo -> GREInfo
IAmConLike ConInfo
con_info) Parent
p (ConLikeName -> Name
conLikeName_Name ConLikeName
con_nm )
mkLocalFieldGREs :: Parent -> [(ConLikeName, ConInfo)] -> [GlobalRdrElt]
mkLocalFieldGREs :: Parent -> [(ConLikeName, ConInfo)] -> [GlobalRdrElt]
mkLocalFieldGREs Parent
p [(ConLikeName, ConInfo)]
cons =
[ GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalGRE (RecFieldInfo -> GREInfo
IAmRecField RecFieldInfo
fld_info) Parent
p Name
fld_nm
| (S.Arg Name
fld_nm FieldLabel
fl, UniqSet ConLikeName
fl_cons) <- [(Arg Name FieldLabel, UniqSet ConLikeName)]
flds
, let fld_info :: RecFieldInfo
fld_info = RecFieldInfo { recFieldLabel :: FieldLabel
recFieldLabel = FieldLabel
fl
, recFieldCons :: UniqSet ConLikeName
recFieldCons = UniqSet ConLikeName
fl_cons } ]
where
flds :: [(Arg Name FieldLabel, UniqSet ConLikeName)]
flds = Map (Arg Name FieldLabel) (UniqSet ConLikeName)
-> [(Arg Name FieldLabel, UniqSet ConLikeName)]
forall k a. Map k a -> [(k, a)]
Map.toList
(Map (Arg Name FieldLabel) (UniqSet ConLikeName)
-> [(Arg Name FieldLabel, UniqSet ConLikeName)])
-> Map (Arg Name FieldLabel) (UniqSet ConLikeName)
-> [(Arg Name FieldLabel, UniqSet ConLikeName)]
forall a b. (a -> b) -> a -> b
$ (UniqSet ConLikeName -> UniqSet ConLikeName -> UniqSet ConLikeName)
-> [(Arg Name FieldLabel, UniqSet ConLikeName)]
-> Map (Arg Name FieldLabel) (UniqSet ConLikeName)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith UniqSet ConLikeName -> UniqSet ConLikeName -> UniqSet ConLikeName
forall a. UniqSet a -> UniqSet a -> UniqSet a
unionUniqSets
[ (Name -> FieldLabel -> Arg Name FieldLabel
forall a b. a -> b -> Arg a b
S.Arg (FieldLabel -> Name
flSelector FieldLabel
fl) FieldLabel
fl, ConLikeName -> UniqSet ConLikeName
forall a. Uniquable a => a -> UniqSet a
unitUniqSet ConLikeName
con)
| (ConLikeName
con, ConInfo
con_info) <- [(ConLikeName, ConInfo)]
cons
, ConInfo ConLikeInfo
_ (ConHasRecordFields NonEmpty FieldLabel
fls) <- [ConInfo
con_info]
, FieldLabel
fl <- NonEmpty FieldLabel -> [FieldLabel]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty FieldLabel
fls ]
instance HasOccName (GlobalRdrEltX info) where
occName :: GlobalRdrEltX info -> OccName
occName = GlobalRdrEltX info -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName
greOccName :: GlobalRdrEltX info -> OccName
greOccName :: forall info. GlobalRdrEltX info -> OccName
greOccName ( GRE { gre_name :: forall info. GlobalRdrEltX info -> Name
gre_name = Name
nm } ) = Name -> OccName
nameOccName Name
nm
greDefinitionSrcSpan :: GlobalRdrEltX info -> SrcSpan
greDefinitionSrcSpan :: forall info. GlobalRdrEltX info -> SrcSpan
greDefinitionSrcSpan = Name -> SrcSpan
nameSrcSpan (Name -> SrcSpan)
-> (GlobalRdrEltX info -> Name) -> GlobalRdrEltX info -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName
greDefinitionModule :: GlobalRdrEltX info -> Maybe Module
greDefinitionModule :: forall info. GlobalRdrEltX info -> Maybe Module
greDefinitionModule = Name -> Maybe Module
nameModule_maybe (Name -> Maybe Module)
-> (GlobalRdrEltX info -> Name)
-> GlobalRdrEltX info
-> Maybe Module
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName
greQualModName :: Outputable info => GlobalRdrEltX info -> ModuleName
greQualModName :: forall info. Outputable info => GlobalRdrEltX info -> ModuleName
greQualModName gre :: GlobalRdrEltX info
gre@(GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
| Bool
lcl, Just Module
mod <- GlobalRdrEltX info -> Maybe Module
forall info. GlobalRdrEltX info -> Maybe Module
greDefinitionModule GlobalRdrEltX info
gre = Module -> ModuleName
forall unit. GenModule unit -> ModuleName
moduleName Module
mod
| Just ImportSpec
is <- Bag ImportSpec -> Maybe ImportSpec
forall a. Bag a -> Maybe a
headMaybe Bag ImportSpec
iss = ImpDeclSpec -> ModuleName
is_as (ImportSpec -> ImpDeclSpec
is_decl ImportSpec
is)
| Bool
otherwise = String -> SDoc -> ModuleName
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"greQualModName" (GlobalRdrEltX info -> SDoc
forall a. Outputable a => a -> SDoc
ppr GlobalRdrEltX info
gre)
greRdrNames :: GlobalRdrEltX info -> [RdrName]
greRdrNames :: forall info. GlobalRdrEltX info -> [RdrName]
greRdrNames gre :: GlobalRdrEltX info
gre@GRE{ gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss }
= Bag RdrName -> [RdrName]
forall a. Bag a -> [a]
bagToList (Bag RdrName -> [RdrName]) -> Bag RdrName -> [RdrName]
forall a b. (a -> b) -> a -> b
$ (if Bool
lcl then RdrName -> Bag RdrName
forall a. a -> Bag a
unitBag RdrName
unqual else Bag RdrName
forall a. Bag a
emptyBag) Bag RdrName -> Bag RdrName -> Bag RdrName
forall a. Bag a -> Bag a -> Bag a
`unionBags` (ImpDeclSpec -> Bag RdrName) -> Bag ImpDeclSpec -> Bag RdrName
forall a b. (a -> Bag b) -> Bag a -> Bag b
concatMapBag ImpDeclSpec -> Bag RdrName
do_spec ((ImportSpec -> ImpDeclSpec) -> Bag ImportSpec -> Bag ImpDeclSpec
forall a b. (a -> b) -> Bag a -> Bag b
mapBag ImportSpec -> ImpDeclSpec
is_decl Bag ImportSpec
iss)
where
occ :: OccName
occ = GlobalRdrEltX info -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName GlobalRdrEltX info
gre
unqual :: RdrName
unqual = OccName -> RdrName
Unqual OccName
occ
do_spec :: ImpDeclSpec -> Bag RdrName
do_spec ImpDeclSpec
decl_spec
| ImpDeclSpec -> Bool
is_qual ImpDeclSpec
decl_spec = RdrName -> Bag RdrName
forall a. a -> Bag a
unitBag RdrName
qual
| Bool
otherwise = [RdrName] -> Bag RdrName
forall a. [a] -> Bag a
listToBag [RdrName
unqual,RdrName
qual]
where qual :: RdrName
qual = ModuleName -> OccName -> RdrName
Qual (ImpDeclSpec -> ModuleName
is_as ImpDeclSpec
decl_spec) OccName
occ
greSrcSpan :: Outputable info => GlobalRdrEltX info -> SrcSpan
greSrcSpan :: forall info. Outputable info => GlobalRdrEltX info -> SrcSpan
greSrcSpan gre :: GlobalRdrEltX info
gre@(GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss } )
| Bool
lcl = GlobalRdrEltX info -> SrcSpan
forall info. GlobalRdrEltX info -> SrcSpan
greDefinitionSrcSpan GlobalRdrEltX info
gre
| Just ImportSpec
is <- Bag ImportSpec -> Maybe ImportSpec
forall a. Bag a -> Maybe a
headMaybe Bag ImportSpec
iss = ImpDeclSpec -> SrcSpan
is_dloc (ImportSpec -> ImpDeclSpec
is_decl ImportSpec
is)
| Bool
otherwise = String -> SDoc -> SrcSpan
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"greSrcSpan" (GlobalRdrEltX info -> SDoc
forall a. Outputable a => a -> SDoc
ppr GlobalRdrEltX info
gre)
mkParent :: Name -> AvailInfo -> Parent
mkParent :: Name -> AvailInfo -> Parent
mkParent Name
_ (Avail Name
_) = Parent
NoParent
mkParent Name
n (AvailTC Name
m [Name]
_) | Name
n Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
m = Parent
NoParent
| Bool
otherwise = Name -> Parent
ParentIs Name
m
availParent :: AvailInfo -> Parent
availParent :: AvailInfo -> Parent
availParent (AvailTC Name
m [Name]
_) = Name -> Parent
ParentIs Name
m
availParent (Avail {}) = Parent
NoParent
greParent_maybe :: GlobalRdrEltX info -> Maybe Name
greParent_maybe :: forall info. GlobalRdrEltX info -> Maybe Name
greParent_maybe GlobalRdrEltX info
gre = case GlobalRdrEltX info -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par GlobalRdrEltX info
gre of
Parent
NoParent -> Maybe Name
forall a. Maybe a
Nothing
ParentIs Name
n -> Name -> Maybe Name
forall a. a -> Maybe a
Just Name
n
gresToNameSet :: [GlobalRdrEltX info] -> NameSet
gresToNameSet :: forall info. [GlobalRdrEltX info] -> NameSet
gresToNameSet [GlobalRdrEltX info]
gres = (GlobalRdrEltX info -> NameSet -> NameSet)
-> NameSet -> [GlobalRdrEltX info] -> NameSet
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GlobalRdrEltX info -> NameSet -> NameSet
forall {info}. GlobalRdrEltX info -> NameSet -> NameSet
add NameSet
emptyNameSet [GlobalRdrEltX info]
gres
where add :: GlobalRdrEltX info -> NameSet -> NameSet
add GlobalRdrEltX info
gre NameSet
set = NameSet -> Name -> NameSet
extendNameSet NameSet
set (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre)
gresToAvailInfo :: forall info. [GlobalRdrEltX info] -> [AvailInfo]
gresToAvailInfo :: forall info. [GlobalRdrEltX info] -> [AvailInfo]
gresToAvailInfo [GlobalRdrEltX info]
gres
= NameEnv AvailInfo -> [AvailInfo]
forall a. NameEnv a -> [a]
nonDetNameEnvElts NameEnv AvailInfo
avail_env
where
avail_env :: NameEnv AvailInfo
(NameEnv AvailInfo
avail_env, NameSet
_) = ((NameEnv AvailInfo, NameSet)
-> GlobalRdrEltX info -> (NameEnv AvailInfo, NameSet))
-> (NameEnv AvailInfo, NameSet)
-> [GlobalRdrEltX info]
-> (NameEnv AvailInfo, NameSet)
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (NameEnv AvailInfo, NameSet)
-> GlobalRdrEltX info -> (NameEnv AvailInfo, NameSet)
add (NameEnv AvailInfo
forall a. NameEnv a
emptyNameEnv, NameSet
emptyNameSet) [GlobalRdrEltX info]
gres
add :: (NameEnv AvailInfo, NameSet)
-> GlobalRdrEltX info
-> (NameEnv AvailInfo, NameSet)
add :: (NameEnv AvailInfo, NameSet)
-> GlobalRdrEltX info -> (NameEnv AvailInfo, NameSet)
add (NameEnv AvailInfo
env, NameSet
done) GlobalRdrEltX info
gre
| Name
name Name -> NameSet -> Bool
`elemNameSet` NameSet
done
= (NameEnv AvailInfo
env, NameSet
done)
| Bool
otherwise
= ( (GlobalRdrEltX info -> AvailInfo -> AvailInfo)
-> (GlobalRdrEltX info -> AvailInfo)
-> NameEnv AvailInfo
-> Name
-> GlobalRdrEltX info
-> NameEnv AvailInfo
forall a b.
(a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b
extendNameEnv_Acc GlobalRdrEltX info -> AvailInfo -> AvailInfo
comb GlobalRdrEltX info -> AvailInfo
forall info. GlobalRdrEltX info -> AvailInfo
availFromGRE NameEnv AvailInfo
env Name
key GlobalRdrEltX info
gre
, NameSet
done NameSet -> Name -> NameSet
`extendNameSet` Name
name )
where
name :: Name
name = GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre
key :: Name
key = case GlobalRdrEltX info -> Maybe Name
forall info. GlobalRdrEltX info -> Maybe Name
greParent_maybe GlobalRdrEltX info
gre of
Just Name
parent -> Name
parent
Maybe Name
Nothing -> GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre
insertChildIntoChildren :: Name -> [Name] -> Name -> [Name]
insertChildIntoChildren :: Name -> [Name] -> Name -> [Name]
insertChildIntoChildren Name
_ [] Name
k = [Name
k]
insertChildIntoChildren Name
p (Name
n:[Name]
ns) Name
k
| Name
p Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
k = Name
kName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:Name
nName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:[Name]
ns
| Bool
otherwise = Name
nName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:Name
kName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:[Name]
ns
comb :: GlobalRdrEltX info -> AvailInfo -> AvailInfo
comb :: GlobalRdrEltX info -> AvailInfo -> AvailInfo
comb GlobalRdrEltX info
_ (Avail Name
n) = Name -> AvailInfo
Avail Name
n
comb GlobalRdrEltX info
gre (AvailTC Name
m [Name]
ns)
= case GlobalRdrEltX info -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par GlobalRdrEltX info
gre of
Parent
NoParent -> Name -> [Name] -> AvailInfo
AvailTC Name
m (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
greName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:[Name]
ns)
ParentIs {} -> Name -> [Name] -> AvailInfo
AvailTC Name
m (Name -> [Name] -> Name -> [Name]
insertChildIntoChildren Name
m [Name]
ns (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre))
availFromGRE :: GlobalRdrEltX info -> AvailInfo
availFromGRE :: forall info. GlobalRdrEltX info -> AvailInfo
availFromGRE (GRE { gre_name :: forall info. GlobalRdrEltX info -> Name
gre_name = Name
child, gre_par :: forall info. GlobalRdrEltX info -> Parent
gre_par = Parent
parent })
= case Parent
parent of
ParentIs Name
p
-> Name -> [Name] -> AvailInfo
AvailTC Name
p [Name
child]
Parent
NoParent
| Name -> Bool
isTyConName Name
child
-> Name -> [Name] -> AvailInfo
AvailTC Name
child [Name
child]
| Bool
otherwise
-> Name -> AvailInfo
Avail Name
child
emptyGlobalRdrEnv :: GlobalRdrEnvX info
emptyGlobalRdrEnv :: forall info. GlobalRdrEnvX info
emptyGlobalRdrEnv = OccEnv [GlobalRdrEltX info]
forall a. OccEnv a
emptyOccEnv
globalRdrEnvElts :: GlobalRdrEnvX info -> [GlobalRdrEltX info]
globalRdrEnvElts :: forall info. GlobalRdrEnvX info -> [GlobalRdrEltX info]
globalRdrEnvElts GlobalRdrEnvX info
env = ([GlobalRdrEltX info]
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> [GlobalRdrEltX info]
-> GlobalRdrEnvX info
-> [GlobalRdrEltX info]
forall a b. (a -> b -> b) -> b -> OccEnv a -> b
nonDetFoldOccEnv [GlobalRdrEltX info]
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a. [a] -> [a] -> [a]
(++) [] GlobalRdrEnvX info
env
globalRdrEnvLocal :: GlobalRdrEnvX info -> GlobalRdrEnvX info
globalRdrEnvLocal :: forall info. GlobalRdrEnvX info -> GlobalRdrEnvX info
globalRdrEnvLocal = ([GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> OccEnv [GlobalRdrEltX info] -> OccEnv [GlobalRdrEltX info]
forall a b. (a -> b) -> OccEnv a -> OccEnv b
mapOccEnv ((GlobalRdrEltX info -> Bool)
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a. (a -> Bool) -> [a] -> [a]
filter GlobalRdrEltX info -> Bool
forall info. GlobalRdrEltX info -> Bool
isLocalGRE)
forceGlobalRdrEnv :: GlobalRdrEnvX info -> IfGlobalRdrEnv
forceGlobalRdrEnv :: forall info. GlobalRdrEnvX info -> IfGlobalRdrEnv
forceGlobalRdrEnv GlobalRdrEnvX info
rdrs =
([GlobalRdrEltX info] -> [GlobalRdrEltX ()])
-> GlobalRdrEnvX info -> IfGlobalRdrEnv
forall a b. (a -> b) -> OccEnv a -> OccEnv b
strictMapOccEnv ((GlobalRdrEltX info -> GlobalRdrEltX ())
-> [GlobalRdrEltX info] -> [GlobalRdrEltX ()]
forall a b. (a -> b) -> [a] -> [b]
strictMap (\ GlobalRdrEltX info
gre -> GlobalRdrEltX info
gre { gre_info = ()})) GlobalRdrEnvX info
rdrs
hydrateGlobalRdrEnv :: forall info noInfo
. (Name -> IO info)
-> GlobalRdrEnvX noInfo -> GlobalRdrEnvX info
hydrateGlobalRdrEnv :: forall info noInfo.
(Name -> IO info) -> GlobalRdrEnvX noInfo -> GlobalRdrEnvX info
hydrateGlobalRdrEnv Name -> IO info
f = ([GlobalRdrEltX noInfo] -> [GlobalRdrEltX info])
-> OccEnv [GlobalRdrEltX noInfo] -> OccEnv [GlobalRdrEltX info]
forall a b. (a -> b) -> OccEnv a -> OccEnv b
mapOccEnv ((GlobalRdrEltX noInfo -> GlobalRdrEltX info)
-> [GlobalRdrEltX noInfo] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GlobalRdrEltX noInfo -> GlobalRdrEltX info
g)
where
g :: GlobalRdrEltX noInfo -> GlobalRdrEltX info
g GlobalRdrEltX noInfo
gre = GlobalRdrEltX noInfo
gre { gre_info = unsafePerformIO $ f (greName gre) }
instance Outputable info => Outputable (GlobalRdrEltX info) where
ppr :: GlobalRdrEltX info -> SDoc
ppr GlobalRdrEltX info
gre = SDoc -> Int -> SDoc -> SDoc
hang (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Parent -> SDoc
forall a. Outputable a => a -> SDoc
ppr (GlobalRdrEltX info -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par GlobalRdrEltX info
gre) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> info -> SDoc
forall a. Outputable a => a -> SDoc
ppr (GlobalRdrEltX info -> info
forall info. GlobalRdrEltX info -> info
gre_info GlobalRdrEltX info
gre))
Int
2 (GlobalRdrEltX info -> SDoc
forall info. GlobalRdrEltX info -> SDoc
pprNameProvenance GlobalRdrEltX info
gre)
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
pprGlobalRdrEnv Bool
locals_only GlobalRdrEnv
env
= [SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"GlobalRdrEnv" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Bool -> SDoc -> SDoc
forall doc. IsOutput doc => Bool -> doc -> doc
ppWhen Bool
locals_only (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"(locals only)")
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
forall doc. IsLine doc => doc
lbrace
, Int -> SDoc -> SDoc
nest Int
2 ([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ [GlobalRdrElt] -> SDoc
forall {info}. Outputable info => [GlobalRdrEltX info] -> SDoc
pp ([GlobalRdrElt] -> [GlobalRdrElt]
remove_locals [GlobalRdrElt]
gre_list) | [GlobalRdrElt]
gre_list <- GlobalRdrEnv -> [[GlobalRdrElt]]
forall a. OccEnv a -> [a]
nonDetOccEnvElts GlobalRdrEnv
env ]
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
forall doc. IsLine doc => doc
rbrace) ]
where
remove_locals :: [GlobalRdrElt] -> [GlobalRdrElt]
remove_locals [GlobalRdrElt]
gres | Bool
locals_only = (GlobalRdrElt -> Bool) -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a. (a -> Bool) -> [a] -> [a]
filter GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isLocalGRE [GlobalRdrElt]
gres
| Bool
otherwise = [GlobalRdrElt]
gres
pp :: [GlobalRdrEltX info] -> SDoc
pp [] = SDoc
forall doc. IsOutput doc => doc
empty
pp gres :: [GlobalRdrEltX info]
gres@(GlobalRdrEltX info
gre:[GlobalRdrEltX info]
_) = SDoc -> Int -> SDoc -> SDoc
hang (OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
forall doc. IsLine doc => doc
colon)
Int
2 ([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat ((GlobalRdrEltX info -> SDoc) -> [GlobalRdrEltX info] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrEltX info -> SDoc
forall a. Outputable a => a -> SDoc
ppr [GlobalRdrEltX info]
gres))
where
occ :: OccName
occ = Name -> OccName
nameOccName (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre)
fieldGRE_maybe :: GlobalRdrElt -> Maybe FieldGlobalRdrElt
fieldGRE_maybe :: GlobalRdrElt -> Maybe GlobalRdrElt
fieldGRE_maybe GlobalRdrElt
gre = do
Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre)
GlobalRdrElt -> Maybe GlobalRdrElt
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return GlobalRdrElt
gre
fieldGRELabel :: HasDebugCallStack => FieldGlobalRdrElt -> FieldLabel
fieldGRELabel :: HasDebugCallStack => GlobalRdrElt -> FieldLabel
fieldGRELabel = RecFieldInfo -> FieldLabel
recFieldLabel (RecFieldInfo -> FieldLabel)
-> (GlobalRdrElt -> RecFieldInfo) -> GlobalRdrElt -> FieldLabel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasDebugCallStack => GlobalRdrElt -> RecFieldInfo
GlobalRdrElt -> RecFieldInfo
fieldGREInfo
fieldGREInfo :: HasDebugCallStack => FieldGlobalRdrElt -> RecFieldInfo
fieldGREInfo :: HasDebugCallStack => GlobalRdrElt -> RecFieldInfo
fieldGREInfo GlobalRdrElt
gre
= Bool -> SDoc -> RecFieldInfo -> RecFieldInfo
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre) (GlobalRdrElt -> SDoc
forall a. Outputable a => a -> SDoc
ppr GlobalRdrElt
gre) (RecFieldInfo -> RecFieldInfo) -> RecFieldInfo -> RecFieldInfo
forall a b. (a -> b) -> a -> b
$
case GlobalRdrElt -> GREInfo
greInfo GlobalRdrElt
gre of
IAmRecField RecFieldInfo
info -> RecFieldInfo
info
GREInfo
info -> String -> SDoc -> RecFieldInfo
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"fieldGREInfo" (SDoc -> RecFieldInfo) -> SDoc -> RecFieldInfo
forall a b. (a -> b) -> a -> b
$
[SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"gre_name:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr (GlobalRdrElt -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrElt
gre)
, String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"info:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> GREInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr GREInfo
info ]
recFieldConLike_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe ConInfo
recFieldConLike_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe ConInfo
recFieldConLike_maybe GlobalRdrElt
gre =
case GlobalRdrElt -> GREInfo
greInfo GlobalRdrElt
gre of
IAmConLike ConInfo
info -> ConInfo -> Maybe ConInfo
forall a. a -> Maybe a
Just ConInfo
info
GREInfo
_ -> Maybe ConInfo
forall a. Maybe a
Nothing
recFieldInfo_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe RecFieldInfo
recFieldInfo_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe RecFieldInfo
recFieldInfo_maybe GlobalRdrElt
gre =
case GlobalRdrElt -> GREInfo
greInfo GlobalRdrElt
gre of
IAmRecField RecFieldInfo
info -> Bool -> SDoc -> Maybe RecFieldInfo -> Maybe RecFieldInfo
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre) (GlobalRdrElt -> SDoc
forall a. Outputable a => a -> SDoc
ppr GlobalRdrElt
gre) (Maybe RecFieldInfo -> Maybe RecFieldInfo)
-> Maybe RecFieldInfo -> Maybe RecFieldInfo
forall a b. (a -> b) -> a -> b
$ RecFieldInfo -> Maybe RecFieldInfo
forall a. a -> Maybe a
Just RecFieldInfo
info
GREInfo
_ -> Maybe RecFieldInfo
forall a. Maybe a
Nothing
data FieldsOrSelectors
= WantNormal
| WantBoth
| WantField
deriving (FieldsOrSelectors -> FieldsOrSelectors -> Bool
(FieldsOrSelectors -> FieldsOrSelectors -> Bool)
-> (FieldsOrSelectors -> FieldsOrSelectors -> Bool)
-> Eq FieldsOrSelectors
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
== :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
$c/= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
/= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
Eq, Int -> FieldsOrSelectors -> ShowS
[FieldsOrSelectors] -> ShowS
FieldsOrSelectors -> String
(Int -> FieldsOrSelectors -> ShowS)
-> (FieldsOrSelectors -> String)
-> ([FieldsOrSelectors] -> ShowS)
-> Show FieldsOrSelectors
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldsOrSelectors -> ShowS
showsPrec :: Int -> FieldsOrSelectors -> ShowS
$cshow :: FieldsOrSelectors -> String
show :: FieldsOrSelectors -> String
$cshowList :: [FieldsOrSelectors] -> ShowS
showList :: [FieldsOrSelectors] -> ShowS
Show)
filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
filterFieldGREs FieldsOrSelectors
WantBoth = [GlobalRdrElt] -> [GlobalRdrElt]
forall a. a -> a
id
filterFieldGREs FieldsOrSelectors
fos = (GlobalRdrElt -> Bool) -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a. (a -> Bool) -> [a] -> [a]
filter (FieldsOrSelectors -> GlobalRdrElt -> Bool
allowGRE FieldsOrSelectors
fos)
allowGRE :: FieldsOrSelectors -> GlobalRdrElt -> Bool
allowGRE :: FieldsOrSelectors -> GlobalRdrElt -> Bool
allowGRE FieldsOrSelectors
WantBoth GlobalRdrElt
_
= Bool
True
allowGRE FieldsOrSelectors
WantNormal GlobalRdrElt
gre
| GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre
= FieldLabel -> FieldSelectors
flHasFieldSelector (HasDebugCallStack => GlobalRdrElt -> FieldLabel
GlobalRdrElt -> FieldLabel
fieldGRELabel GlobalRdrElt
gre) FieldSelectors -> FieldSelectors -> Bool
forall a. Eq a => a -> a -> Bool
== FieldSelectors
FieldSelectors
| Bool
otherwise
= Bool
True
allowGRE FieldsOrSelectors
WantField GlobalRdrElt
gre
= GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre
data ParentGRE
= ParentGRE
{ ParentGRE -> Name
parentGRE_name :: Name
, ParentGRE -> GREInfo
parentGRE_info :: GREInfo
}
instance Outputable ParentGRE where
ppr :: ParentGRE -> SDoc
ppr (ParentGRE Name
name GREInfo
info) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
parens (GREInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr GREInfo
info)
instance Eq ParentGRE where
ParentGRE Name
name1 GREInfo
_ == :: ParentGRE -> ParentGRE -> Bool
== ParentGRE Name
name2 GREInfo
_ = Name
name1 Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
name2
data LookupGRE info where
LookupOccName :: OccName
-> WhichGREs info
-> LookupGRE info
LookupRdrName :: RdrName
-> WhichGREs info
-> LookupGRE info
LookupExactName
:: { forall info. LookupGRE info -> Name
lookupExactName :: Name
, forall info. LookupGRE info -> Bool
lookInAllNameSpaces :: Bool
}
-> LookupGRE info
LookupChildren
:: ParentGRE
-> OccName
-> LookupGRE GREInfo
data WhichGREs info where
SameNameSpace :: WhichGREs info
RelevantGREs
:: { WhichGREs GREInfo -> FieldsOrSelectors
includeFieldSelectors :: !FieldsOrSelectors
, WhichGREs GREInfo -> Bool
lookupVariablesForFields :: !Bool
, WhichGREs GREInfo -> Bool
lookupTyConsAsWell :: !Bool
}
-> WhichGREs GREInfo
instance Outputable (WhichGREs info) where
ppr :: WhichGREs info -> SDoc
ppr WhichGREs info
SameNameSpace = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"SameNameSpace"
ppr (RelevantGREs { includeFieldSelectors :: WhichGREs GREInfo -> FieldsOrSelectors
includeFieldSelectors = FieldsOrSelectors
sel
, lookupVariablesForFields :: WhichGREs GREInfo -> Bool
lookupVariablesForFields = Bool
vars
, lookupTyConsAsWell :: WhichGREs GREInfo -> Bool
lookupTyConsAsWell = Bool
tcs_too })
= SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
braces (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
forall doc. IsLine doc => [doc] -> doc
hsep
[ String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"RelevantGREs"
, String -> SDoc
forall doc. IsLine doc => String -> doc
text (FieldsOrSelectors -> String
forall a. Show a => a -> String
show FieldsOrSelectors
sel)
, if Bool
vars then String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"[vars]" else SDoc
forall doc. IsOutput doc => doc
empty
, if Bool
tcs_too then String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"[tcs]" else SDoc
forall doc. IsOutput doc => doc
empty ]
pattern AllRelevantGREs :: WhichGREs GREInfo
pattern $mAllRelevantGREs :: forall {r}. WhichGREs GREInfo -> ((# #) -> r) -> ((# #) -> r) -> r
$bAllRelevantGREs :: WhichGREs GREInfo
AllRelevantGREs =
RelevantGREs { includeFieldSelectors = WantBoth
, lookupVariablesForFields = True
, lookupTyConsAsWell = True }
pattern RelevantGREsFOS :: FieldsOrSelectors -> WhichGREs GREInfo
pattern $mRelevantGREsFOS :: forall {r}.
WhichGREs GREInfo -> (FieldsOrSelectors -> r) -> ((# #) -> r) -> r
$bRelevantGREsFOS :: FieldsOrSelectors -> WhichGREs GREInfo
RelevantGREsFOS fos <- RelevantGREs { includeFieldSelectors = fos }
where
RelevantGREsFOS FieldsOrSelectors
fos =
RelevantGREs { includeFieldSelectors :: FieldsOrSelectors
includeFieldSelectors = FieldsOrSelectors
fos
, lookupVariablesForFields :: Bool
lookupVariablesForFields = FieldsOrSelectors
fos FieldsOrSelectors -> FieldsOrSelectors -> Bool
forall a. Eq a => a -> a -> Bool
== FieldsOrSelectors
WantBoth
, lookupTyConsAsWell :: Bool
lookupTyConsAsWell = Bool
False }
greIsRelevant :: WhichGREs GREInfo
-> NameSpace
-> GlobalRdrElt
-> Bool
greIsRelevant :: WhichGREs GREInfo -> NameSpace -> GlobalRdrElt -> Bool
greIsRelevant WhichGREs GREInfo
which_gres NameSpace
ns GlobalRdrElt
gre
| NameSpace
ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
other_ns
= Bool
True
| Bool
otherwise
= case WhichGREs GREInfo
which_gres of
WhichGREs GREInfo
SameNameSpace -> Bool
False
RelevantGREs { includeFieldSelectors :: WhichGREs GREInfo -> FieldsOrSelectors
includeFieldSelectors = FieldsOrSelectors
fos
, lookupVariablesForFields :: WhichGREs GREInfo -> Bool
lookupVariablesForFields = Bool
vars_for_flds
, lookupTyConsAsWell :: WhichGREs GREInfo -> Bool
lookupTyConsAsWell = Bool
tycons_too }
| NameSpace
ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
varName
-> (NameSpace -> Bool
isFieldNameSpace NameSpace
other_ns Bool -> Bool -> Bool
&& FieldsOrSelectors -> GlobalRdrElt -> Bool
allowGRE FieldsOrSelectors
fos GlobalRdrElt
gre) Bool -> Bool -> Bool
|| Bool
tc_too
| NameSpace -> Bool
isFieldNameSpace NameSpace
ns
-> Bool
vars_for_flds Bool -> Bool -> Bool
&&
( NameSpace
other_ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
varName
Bool -> Bool -> Bool
|| (NameSpace -> Bool
isFieldNameSpace NameSpace
other_ns Bool -> Bool -> Bool
&& FieldsOrSelectors -> GlobalRdrElt -> Bool
allowGRE FieldsOrSelectors
fos GlobalRdrElt
gre)
Bool -> Bool -> Bool
|| Bool
tc_too )
| NameSpace -> Bool
isDataConNameSpace NameSpace
ns
-> Bool
tc_too
| Bool
otherwise
-> Bool
False
where
tc_too :: Bool
tc_too = Bool
tycons_too Bool -> Bool -> Bool
&& NameSpace -> Bool
isTcClsNameSpace NameSpace
other_ns
where
other_ns :: NameSpace
other_ns = GlobalRdrElt -> NameSpace
forall info. GlobalRdrEltX info -> NameSpace
greNameSpace GlobalRdrElt
gre
childGREPriority :: ParentGRE
-> NameSpace
-> GlobalRdrElt
-> Maybe (Int, Int)
childGREPriority :: ParentGRE -> NameSpace -> GlobalRdrElt -> Maybe (Int, Int)
childGREPriority (ParentGRE Name
wanted_parent GREInfo
parent_info) NameSpace
wanted_ns GlobalRdrElt
child_gre =
(Int
parent_prio, ) (Int -> (Int, Int)) -> Maybe Int -> Maybe (Int, Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int
child_ns_prio
where
child_ns :: NameSpace
child_ns = GlobalRdrElt -> NameSpace
forall info. GlobalRdrEltX info -> NameSpace
greNameSpace GlobalRdrElt
child_gre
is_class_parent :: Bool
is_class_parent =
case GREInfo
parent_info of
IAmTyCon TyConFlavour Name
ClassFlavour -> Bool
True
GREInfo
_ -> Bool
False
child_ns_prio :: Maybe Int
child_ns_prio :: Maybe Int
child_ns_prio
| NameSpace
child_ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
wanted_ns
, Bool -> Bool
not (NameSpace -> Bool
isTcClsNameSpace NameSpace
child_ns) Bool -> Bool -> Bool
|| Bool
is_class_parent Bool -> Bool -> Bool
|| Bool
child_is_data
= Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
| NameSpace -> Bool
isTermVarOrFieldNameSpace NameSpace
wanted_ns
, NameSpace -> Bool
isTermVarOrFieldNameSpace NameSpace
child_ns
= Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0
| NameSpace -> Bool
isValNameSpace NameSpace
wanted_ns
, Bool
is_class_parent Bool -> Bool -> Bool
&& NameSpace -> Bool
isTcClsNameSpace NameSpace
child_ns
= Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
| NameSpace
wanted_ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
tcName
, Bool
child_is_data
= Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$
if Bool
is_class_parent
then Int
1
else -Int
1
| Bool
otherwise
= Maybe Int
forall a. Maybe a
Nothing
parent_prio :: Int
parent_prio :: Int
parent_prio =
case GlobalRdrElt -> Parent
forall info. GlobalRdrEltX info -> Parent
greParent GlobalRdrElt
child_gre of
ParentIs Name
other_parent
| Name
other_parent Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
wanted_parent
-> Int
0
| Bool
otherwise
-> Int
1
Parent
NoParent ->
Int
0
child_is_data :: Bool
child_is_data =
case GlobalRdrElt -> GREInfo
greInfo GlobalRdrElt
child_gre of
IAmConLike{} -> Bool
True
IAmTyCon TyConFlavour Name
PromotedDataConFlavour -> Bool
True
GREInfo
_ -> NameSpace
child_ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
dataName
lookupGRE :: GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
lookupGRE :: forall info.
GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
lookupGRE GlobalRdrEnvX info
env = \case
LookupOccName OccName
occ WhichGREs info
which_gres ->
case WhichGREs info
which_gres of
WhichGREs info
SameNameSpace ->
Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> OccName -> Maybe [GlobalRdrEltX info]
forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv GlobalRdrEnvX info
env OccName
occ
rel :: WhichGREs info
rel@(RelevantGREs{}) ->
(GlobalRdrEltX info -> Bool)
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a. (a -> Bool) -> [a] -> [a]
filter (WhichGREs GREInfo -> NameSpace -> GlobalRdrElt -> Bool
greIsRelevant WhichGREs info
WhichGREs GREInfo
rel (OccName -> NameSpace
occNameSpace OccName
occ)) ([GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$
[[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[GlobalRdrEltX info]] -> [GlobalRdrEltX info])
-> [[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> OccName -> [[GlobalRdrEltX info]]
forall a. OccEnv a -> OccName -> [a]
lookupOccEnv_AllNameSpaces GlobalRdrEnvX info
env OccName
occ
LookupRdrName RdrName
rdr WhichGREs info
rel ->
RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall info.
RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
pickGREs RdrName
rdr ([GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
forall info.
GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
lookupGRE GlobalRdrEnvX info
env (OccName -> WhichGREs info -> LookupGRE info
forall info. OccName -> WhichGREs info -> LookupGRE info
LookupOccName (RdrName -> OccName
rdrNameOcc RdrName
rdr) WhichGREs info
rel)
LookupExactName { lookupExactName :: forall info. LookupGRE info -> Name
lookupExactName = Name
nm
, lookInAllNameSpaces :: forall info. LookupGRE info -> Bool
lookInAllNameSpaces = Bool
all_ns } ->
[ GlobalRdrEltX info
gre | GlobalRdrEltX info
gre <- [GlobalRdrEltX info]
lkup, GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
nm ]
where
occ :: OccName
occ = Name -> OccName
nameOccName Name
nm
lkup :: [GlobalRdrEltX info]
lkup | Bool
all_ns = [[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[GlobalRdrEltX info]] -> [GlobalRdrEltX info])
-> [[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> OccName -> [[GlobalRdrEltX info]]
forall a. OccEnv a -> OccName -> [a]
lookupOccEnv_AllNameSpaces GlobalRdrEnvX info
env OccName
occ
| Bool
otherwise = [GlobalRdrEltX info]
-> Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info])
-> Maybe [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> OccName -> Maybe [GlobalRdrEltX info]
forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv GlobalRdrEnvX info
env OccName
occ
LookupChildren ParentGRE
parent OccName
child_occ ->
let ns :: NameSpace
ns = OccName -> NameSpace
occNameSpace OccName
child_occ
all_gres :: [GlobalRdrEltX info]
all_gres = [[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[GlobalRdrEltX info]] -> [GlobalRdrEltX info])
-> [[GlobalRdrEltX info]] -> [GlobalRdrEltX info]
forall a b. (a -> b) -> a -> b
$ GlobalRdrEnvX info -> OccName -> [[GlobalRdrEltX info]]
forall a. OccEnv a -> OccName -> [a]
lookupOccEnv_AllNameSpaces GlobalRdrEnvX info
env OccName
child_occ
in (GlobalRdrEltX info -> Maybe (Int, Int))
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall gre prio. Ord prio => (gre -> Maybe prio) -> [gre] -> [gre]
highestPriorityGREs (ParentGRE -> NameSpace -> GlobalRdrElt -> Maybe (Int, Int)
childGREPriority ParentGRE
parent NameSpace
ns) [GlobalRdrEltX info]
all_gres
highestPriorityGREs :: forall gre prio
. Ord prio
=> (gre -> Maybe prio)
-> [gre] -> [gre]
highestPriorityGREs :: forall gre prio. Ord prio => (gre -> Maybe prio) -> [gre] -> [gre]
highestPriorityGREs gre -> Maybe prio
priority [gre]
gres =
[NonEmpty (Arg prio gre)] -> [gre]
take_highest_prio ([NonEmpty (Arg prio gre)] -> [gre])
-> [NonEmpty (Arg prio gre)] -> [gre]
forall a b. (a -> b) -> a -> b
$ [Arg prio gre] -> [NonEmpty (Arg prio gre)]
forall (f :: * -> *) a. (Foldable f, Eq a) => f a -> [NonEmpty a]
NE.group ([Arg prio gre] -> [NonEmpty (Arg prio gre)])
-> [Arg prio gre] -> [NonEmpty (Arg prio gre)]
forall a b. (a -> b) -> a -> b
$ [Arg prio gre] -> [Arg prio gre]
forall a. Ord a => [a] -> [a]
sort
[ prio -> gre -> Arg prio gre
forall a b. a -> b -> Arg a b
S.Arg prio
prio gre
gre
| gre
gre <- [gre]
gres
, prio
prio <- Maybe prio -> [prio]
forall a. Maybe a -> [a]
maybeToList (Maybe prio -> [prio]) -> Maybe prio -> [prio]
forall a b. (a -> b) -> a -> b
$ gre -> Maybe prio
priority gre
gre ]
where
take_highest_prio :: [NE.NonEmpty (S.Arg prio gre)] -> [gre]
take_highest_prio :: [NonEmpty (Arg prio gre)] -> [gre]
take_highest_prio [] = []
take_highest_prio (NonEmpty (Arg prio gre)
fs:[NonEmpty (Arg prio gre)]
_) = (Arg prio gre -> gre) -> [Arg prio gre] -> [gre]
forall a b. (a -> b) -> [a] -> [b]
map (\ (S.Arg prio
_ gre
gre) -> gre
gre) ([Arg prio gre] -> [gre]) -> [Arg prio gre] -> [gre]
forall a b. (a -> b) -> a -> b
$ NonEmpty (Arg prio gre) -> [Arg prio gre]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (Arg prio gre)
fs
{-# INLINEABLE highestPriorityGREs #-}
lookupGRE_Name :: Outputable info => GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
lookupGRE_Name :: forall info.
Outputable info =>
GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
lookupGRE_Name GlobalRdrEnvX info
env Name
name =
case GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
forall info.
GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
lookupGRE GlobalRdrEnvX info
env (LookupExactName { lookupExactName :: Name
lookupExactName = Name
name
, lookInAllNameSpaces :: Bool
lookInAllNameSpaces = Bool
False }) of
[] -> Maybe (GlobalRdrEltX info)
forall a. Maybe a
Nothing
[GlobalRdrEltX info
gre] -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall a. a -> Maybe a
Just GlobalRdrEltX info
gre
[GlobalRdrEltX info]
gres -> String -> SDoc -> Maybe (GlobalRdrEltX info)
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"lookupGRE_Name"
(Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
forall doc. IsDoc doc => doc -> doc -> doc
$$ OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Name -> OccName
nameOccName Name
name) SDoc -> SDoc -> SDoc
forall doc. IsDoc doc => doc -> doc -> doc
$$ [GlobalRdrEltX info] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [GlobalRdrEltX info]
gres)
lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe FieldGlobalRdrElt
lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
lookupGRE_FieldLabel GlobalRdrEnv
env FieldLabel
fl =
case GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
forall info.
Outputable info =>
GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
lookupGRE_Name GlobalRdrEnv
env (FieldLabel -> Name
flSelector FieldLabel
fl) of
Maybe GlobalRdrElt
Nothing -> Maybe GlobalRdrElt
forall a. Maybe a
Nothing
Just GlobalRdrElt
gre ->
Bool -> SDoc -> Maybe GlobalRdrElt -> Maybe GlobalRdrElt
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
isRecFldGRE GlobalRdrElt
gre)
([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [ String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"lookupGre_FieldLabel:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> FieldLabel -> SDoc
forall a. Outputable a => a -> SDoc
ppr FieldLabel
fl ]) (Maybe GlobalRdrElt -> Maybe GlobalRdrElt)
-> Maybe GlobalRdrElt -> Maybe GlobalRdrElt
forall a b. (a -> b) -> a -> b
$
GlobalRdrElt -> Maybe GlobalRdrElt
forall a. a -> Maybe a
Just GlobalRdrElt
gre
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
getGRE_NameQualifier_maybes GlobalRdrEnv
env Name
name
= case GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
forall info.
Outputable info =>
GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
lookupGRE_Name GlobalRdrEnv
env Name
name of
Just GlobalRdrElt
gre -> [GlobalRdrElt -> Maybe [ModuleName]
forall {info}. GlobalRdrEltX info -> Maybe [ModuleName]
qualifier_maybe GlobalRdrElt
gre]
Maybe GlobalRdrElt
Nothing -> []
where
qualifier_maybe :: GlobalRdrEltX info -> Maybe [ModuleName]
qualifier_maybe (GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
| Bool
lcl = Maybe [ModuleName]
forall a. Maybe a
Nothing
| Bool
otherwise = [ModuleName] -> Maybe [ModuleName]
forall a. a -> Maybe a
Just ([ModuleName] -> Maybe [ModuleName])
-> [ModuleName] -> Maybe [ModuleName]
forall a b. (a -> b) -> a -> b
$ (ImportSpec -> ModuleName) -> [ImportSpec] -> [ModuleName]
forall a b. (a -> b) -> [a] -> [b]
map (ImpDeclSpec -> ModuleName
is_as (ImpDeclSpec -> ModuleName)
-> (ImportSpec -> ImpDeclSpec) -> ImportSpec -> ModuleName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImportSpec -> ImpDeclSpec
is_decl) (Bag ImportSpec -> [ImportSpec]
forall a. Bag a -> [a]
bagToList Bag ImportSpec
iss)
isLocalGRE :: GlobalRdrEltX info -> Bool
isLocalGRE :: forall info. GlobalRdrEltX info -> Bool
isLocalGRE (GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl }) = Bool
lcl
isImportedGRE :: GlobalRdrEltX info -> Bool
isImportedGRE :: forall info. GlobalRdrEltX info -> Bool
isImportedGRE (GRE { gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
imps }) = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Bag ImportSpec -> Bool
forall a. Bag a -> Bool
isEmptyBag Bag ImportSpec
imps
isRecFldGRE :: GlobalRdrEltX info -> Bool
isRecFldGRE :: forall info. GlobalRdrEltX info -> Bool
isRecFldGRE (GRE { gre_name :: forall info. GlobalRdrEltX info -> Name
gre_name = Name
nm }) = Name -> Bool
isFieldName Name
nm
isDuplicateRecFldGRE :: GlobalRdrElt -> Bool
isDuplicateRecFldGRE :: GlobalRdrElt -> Bool
isDuplicateRecFldGRE =
Bool -> (FieldLabel -> Bool) -> Maybe FieldLabel -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((DuplicateRecordFields
DuplicateRecordFields DuplicateRecordFields -> DuplicateRecordFields -> Bool
forall a. Eq a => a -> a -> Bool
==) (DuplicateRecordFields -> Bool)
-> (FieldLabel -> DuplicateRecordFields) -> FieldLabel -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldLabel -> DuplicateRecordFields
flHasDuplicateRecordFields) (Maybe FieldLabel -> Bool)
-> (GlobalRdrElt -> Maybe FieldLabel) -> GlobalRdrElt -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> Maybe FieldLabel
greFieldLabel_maybe
isNoFieldSelectorGRE :: GlobalRdrElt -> Bool
isNoFieldSelectorGRE :: GlobalRdrElt -> Bool
isNoFieldSelectorGRE =
Bool -> (FieldLabel -> Bool) -> Maybe FieldLabel -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((FieldSelectors
NoFieldSelectors FieldSelectors -> FieldSelectors -> Bool
forall a. Eq a => a -> a -> Bool
==) (FieldSelectors -> Bool)
-> (FieldLabel -> FieldSelectors) -> FieldLabel -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldLabel -> FieldSelectors
flHasFieldSelector) (Maybe FieldLabel -> Bool)
-> (GlobalRdrElt -> Maybe FieldLabel) -> GlobalRdrElt -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> Maybe FieldLabel
greFieldLabel_maybe
isFieldSelectorGRE :: GlobalRdrElt -> Bool
isFieldSelectorGRE :: GlobalRdrElt -> Bool
isFieldSelectorGRE =
Bool -> (FieldLabel -> Bool) -> Maybe FieldLabel -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((FieldSelectors
FieldSelectors FieldSelectors -> FieldSelectors -> Bool
forall a. Eq a => a -> a -> Bool
==) (FieldSelectors -> Bool)
-> (FieldLabel -> FieldSelectors) -> FieldLabel -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldLabel -> FieldSelectors
flHasFieldSelector) (Maybe FieldLabel -> Bool)
-> (GlobalRdrElt -> Maybe FieldLabel) -> GlobalRdrElt -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> Maybe FieldLabel
greFieldLabel_maybe
greFieldLabel_maybe :: GlobalRdrElt -> Maybe FieldLabel
greFieldLabel_maybe :: GlobalRdrElt -> Maybe FieldLabel
greFieldLabel_maybe = (GlobalRdrElt -> FieldLabel)
-> Maybe GlobalRdrElt -> Maybe FieldLabel
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HasDebugCallStack => GlobalRdrElt -> FieldLabel
GlobalRdrElt -> FieldLabel
fieldGRELabel (Maybe GlobalRdrElt -> Maybe FieldLabel)
-> (GlobalRdrElt -> Maybe GlobalRdrElt)
-> GlobalRdrElt
-> Maybe FieldLabel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> Maybe GlobalRdrElt
fieldGRE_maybe
unQualOK :: GlobalRdrEltX info -> Bool
unQualOK :: forall info. GlobalRdrEltX info -> Bool
unQualOK (GRE {gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
| Bool
lcl = Bool
True
| Bool
otherwise = (ImportSpec -> Bool) -> Bag ImportSpec -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ImportSpec -> Bool
unQualSpecOK Bag ImportSpec
iss
pickGREs :: RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
pickGREs :: forall info.
RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
pickGREs (Unqual {}) [GlobalRdrEltX info]
gres = (GlobalRdrEltX info -> Maybe (GlobalRdrEltX info))
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall info. GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickUnqualGRE [GlobalRdrEltX info]
gres
pickGREs (Qual ModuleName
mod OccName
_) [GlobalRdrEltX info]
gres = (GlobalRdrEltX info -> Maybe (GlobalRdrEltX info))
-> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall info.
ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickQualGRE ModuleName
mod) [GlobalRdrEltX info]
gres
pickGREs RdrName
_ [GlobalRdrEltX info]
_ = []
pickUnqualGRE :: GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickUnqualGRE :: forall info. GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickUnqualGRE gre :: GlobalRdrEltX info
gre@(GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
| Bool -> Bool
not Bool
lcl, Bag ImportSpec -> Bool
forall a. Bag a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Bag ImportSpec
iss' = Maybe (GlobalRdrEltX info)
forall a. Maybe a
Nothing
| Bool
otherwise = GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall a. a -> Maybe a
Just (GlobalRdrEltX info
gre { gre_imp = iss' })
where
iss' :: Bag ImportSpec
iss' = (ImportSpec -> Bool) -> Bag ImportSpec -> Bag ImportSpec
forall a. (a -> Bool) -> Bag a -> Bag a
filterBag ImportSpec -> Bool
unQualSpecOK Bag ImportSpec
iss
pickQualGRE :: ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickQualGRE :: forall info.
ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickQualGRE ModuleName
mod gre :: GlobalRdrEltX info
gre@(GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
| Bool -> Bool
not Bool
lcl', Bag ImportSpec -> Bool
forall a. Bag a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Bag ImportSpec
iss' = Maybe (GlobalRdrEltX info)
forall a. Maybe a
Nothing
| Bool
otherwise = GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall a. a -> Maybe a
Just (GlobalRdrEltX info
gre { gre_lcl = lcl', gre_imp = iss' })
where
iss' :: Bag ImportSpec
iss' = (ImportSpec -> Bool) -> Bag ImportSpec -> Bag ImportSpec
forall a. (a -> Bool) -> Bag a -> Bag a
filterBag (ModuleName -> ImportSpec -> Bool
qualSpecOK ModuleName
mod) Bag ImportSpec
iss
lcl' :: Bool
lcl' = Bool
lcl Bool -> Bool -> Bool
&& ModuleName -> Bool
name_is_from ModuleName
mod
name_is_from :: ModuleName -> Bool
name_is_from :: ModuleName -> Bool
name_is_from ModuleName
mod = case GlobalRdrEltX info -> Maybe Module
forall info. GlobalRdrEltX info -> Maybe Module
greDefinitionModule GlobalRdrEltX info
gre of
Just Module
n_mod -> Module -> ModuleName
forall unit. GenModule unit -> ModuleName
moduleName Module
n_mod ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleName
mod
Maybe Module
Nothing -> Bool
False
pickGREsModExp :: ModuleName -> [GlobalRdrEltX info] -> [(GlobalRdrEltX info,GlobalRdrEltX info)]
pickGREsModExp :: forall info.
ModuleName
-> [GlobalRdrEltX info]
-> [(GlobalRdrEltX info, GlobalRdrEltX info)]
pickGREsModExp ModuleName
mod [GlobalRdrEltX info]
gres = (GlobalRdrEltX info
-> Maybe (GlobalRdrEltX info, GlobalRdrEltX info))
-> [GlobalRdrEltX info]
-> [(GlobalRdrEltX info, GlobalRdrEltX info)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (ModuleName
-> GlobalRdrEltX info
-> Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
forall info.
ModuleName
-> GlobalRdrEltX info
-> Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
pickBothGRE ModuleName
mod) [GlobalRdrEltX info]
gres
pickBothGRE :: ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
pickBothGRE :: forall info.
ModuleName
-> GlobalRdrEltX info
-> Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
pickBothGRE ModuleName
mod GlobalRdrEltX info
gre
| Name -> Bool
isBuiltInSyntax (GlobalRdrEltX info -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrEltX info
gre)
= Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
forall a. Maybe a
Nothing
| Just GlobalRdrEltX info
gre1 <- ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall info.
ModuleName -> GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickQualGRE ModuleName
mod GlobalRdrEltX info
gre
, Just GlobalRdrEltX info
gre2 <- GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
forall info. GlobalRdrEltX info -> Maybe (GlobalRdrEltX info)
pickUnqualGRE GlobalRdrEltX info
gre
= (GlobalRdrEltX info, GlobalRdrEltX info)
-> Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
forall a. a -> Maybe a
Just (GlobalRdrEltX info
gre1, GlobalRdrEltX info
gre2)
| Bool
otherwise
= Maybe (GlobalRdrEltX info, GlobalRdrEltX info)
forall a. Maybe a
Nothing
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
plusGlobalRdrEnv GlobalRdrEnv
env1 GlobalRdrEnv
env2 = ([GlobalRdrElt] -> [GlobalRdrElt] -> [GlobalRdrElt])
-> GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
forall a. (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
plusOccEnv_C ((GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt])
-> [GlobalRdrElt] -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE) GlobalRdrEnv
env1 GlobalRdrEnv
env2
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
mkGlobalRdrEnv [GlobalRdrElt]
gres
= (GlobalRdrElt -> GlobalRdrEnv -> GlobalRdrEnv)
-> GlobalRdrEnv -> [GlobalRdrElt] -> GlobalRdrEnv
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GlobalRdrElt -> GlobalRdrEnv -> GlobalRdrEnv
add GlobalRdrEnv
forall info. GlobalRdrEnvX info
emptyGlobalRdrEnv [GlobalRdrElt]
gres
where
add :: GlobalRdrElt -> GlobalRdrEnv -> GlobalRdrEnv
add GlobalRdrElt
gre GlobalRdrEnv
env = (GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt])
-> (GlobalRdrElt -> [GlobalRdrElt])
-> GlobalRdrEnv
-> OccName
-> GlobalRdrElt
-> GlobalRdrEnv
forall a b.
(a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
extendOccEnv_Acc GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE GlobalRdrElt -> [GlobalRdrElt]
forall a. a -> [a]
Utils.singleton GlobalRdrEnv
env
(GlobalRdrElt -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName GlobalRdrElt
gre)
GlobalRdrElt
gre
insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE GlobalRdrElt
new_g [] = [GlobalRdrElt
new_g]
insertGRE GlobalRdrElt
new_g (GlobalRdrElt
old_g : [GlobalRdrElt]
old_gs)
| GlobalRdrElt -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrElt
new_g Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== GlobalRdrElt -> Name
forall info. GlobalRdrEltX info -> Name
greName GlobalRdrElt
old_g
= GlobalRdrElt
new_g GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
`plusGRE` GlobalRdrElt
old_g GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a. a -> [a] -> [a]
: [GlobalRdrElt]
old_gs
| Bool
otherwise
= GlobalRdrElt
old_g GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a. a -> [a] -> [a]
: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE GlobalRdrElt
new_g [GlobalRdrElt]
old_gs
plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
plusGRE GlobalRdrElt
g1 GlobalRdrElt
g2
= GRE { gre_name :: Name
gre_name = GlobalRdrElt -> Name
forall info. GlobalRdrEltX info -> Name
gre_name GlobalRdrElt
g1
, gre_lcl :: Bool
gre_lcl = GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
gre_lcl GlobalRdrElt
g1 Bool -> Bool -> Bool
|| GlobalRdrElt -> Bool
forall info. GlobalRdrEltX info -> Bool
gre_lcl GlobalRdrElt
g2
, gre_imp :: Bag ImportSpec
gre_imp = GlobalRdrElt -> Bag ImportSpec
forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp GlobalRdrElt
g1 Bag ImportSpec -> Bag ImportSpec -> Bag ImportSpec
forall a. Bag a -> Bag a -> Bag a
`unionBags` GlobalRdrElt -> Bag ImportSpec
forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp GlobalRdrElt
g2
, gre_par :: Parent
gre_par = GlobalRdrElt -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par GlobalRdrElt
g1 Parent -> Parent -> Parent
`plusParent` GlobalRdrElt -> Parent
forall info. GlobalRdrEltX info -> Parent
gre_par GlobalRdrElt
g2
, gre_info :: GREInfo
gre_info = GlobalRdrElt -> GREInfo
forall info. GlobalRdrEltX info -> info
gre_info GlobalRdrElt
g1 GREInfo -> GREInfo -> GREInfo
`plusGREInfo` GlobalRdrElt -> GREInfo
forall info. GlobalRdrEltX info -> info
gre_info GlobalRdrElt
g2 }
transformGREs :: (GlobalRdrElt -> GlobalRdrElt)
-> [OccName]
-> GlobalRdrEnv -> GlobalRdrEnv
transformGREs :: (GlobalRdrElt -> GlobalRdrElt)
-> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv
transformGREs GlobalRdrElt -> GlobalRdrElt
trans_gre [OccName]
occs GlobalRdrEnv
rdr_env
= (OccName -> GlobalRdrEnv -> GlobalRdrEnv)
-> GlobalRdrEnv -> [OccName] -> GlobalRdrEnv
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr OccName -> GlobalRdrEnv -> GlobalRdrEnv
trans GlobalRdrEnv
rdr_env [OccName]
occs
where
trans :: OccName -> GlobalRdrEnv -> GlobalRdrEnv
trans OccName
occ GlobalRdrEnv
env
= case GlobalRdrEnv -> OccName -> Maybe [GlobalRdrElt]
forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv GlobalRdrEnv
env OccName
occ of
Just [GlobalRdrElt]
gres -> GlobalRdrEnv -> OccName -> [GlobalRdrElt] -> GlobalRdrEnv
forall a. OccEnv a -> OccName -> a -> OccEnv a
extendOccEnv GlobalRdrEnv
env OccName
occ ((GlobalRdrElt -> GlobalRdrElt) -> [GlobalRdrElt] -> [GlobalRdrElt]
forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> GlobalRdrElt
trans_gre [GlobalRdrElt]
gres)
Maybe [GlobalRdrElt]
Nothing -> GlobalRdrEnv
env
extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
extendGlobalRdrEnv GlobalRdrEnv
env GlobalRdrElt
gre
= (GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt])
-> (GlobalRdrElt -> [GlobalRdrElt])
-> GlobalRdrEnv
-> OccName
-> GlobalRdrElt
-> GlobalRdrEnv
forall a b.
(a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
extendOccEnv_Acc GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
insertGRE GlobalRdrElt -> [GlobalRdrElt]
forall a. a -> [a]
Utils.singleton GlobalRdrEnv
env
(GlobalRdrElt -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName GlobalRdrElt
gre) GlobalRdrElt
gre
shadowNames :: Bool
-> GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
shadowNames :: Bool -> GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
shadowNames Bool
drop_only_qualified GlobalRdrEnv
env GlobalRdrEnv
new_gres = (UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt])
-> GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
forall a b.
(UniqFM NameSpace a -> UniqFM NameSpace b -> UniqFM NameSpace a)
-> OccEnv a -> OccEnv b -> OccEnv a
minusOccEnv_C_Ns UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
do_shadowing GlobalRdrEnv
env GlobalRdrEnv
new_gres
where
do_shadowing :: UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
do_shadowing :: UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
do_shadowing UniqFM NameSpace [GlobalRdrElt]
olds UniqFM NameSpace [GlobalRdrElt]
news =
let shadowed_gres :: ShadowedGREs
shadowed_gres :: ShadowedGREs
shadowed_gres =
([GlobalRdrElt] -> ShadowedGREs -> ShadowedGREs)
-> ShadowedGREs -> UniqFM NameSpace [GlobalRdrElt] -> ShadowedGREs
forall {k} elt a (key :: k).
(elt -> a -> a) -> a -> UniqFM key elt -> a
nonDetFoldUFM (\ [GlobalRdrElt]
gres ShadowedGREs
shads -> (GlobalRdrElt -> ShadowedGREs) -> [GlobalRdrElt] -> ShadowedGREs
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap GlobalRdrElt -> ShadowedGREs
greShadowedNameSpaces [GlobalRdrElt]
gres ShadowedGREs -> ShadowedGREs -> ShadowedGREs
forall a. Semigroup a => a -> a -> a
S.<> ShadowedGREs
shads)
ShadowedGREs
forall a. Monoid a => a
mempty UniqFM NameSpace [GlobalRdrElt]
news
shadow_list :: Unique -> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
shadow_list :: Unique -> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
shadow_list Unique
old_ns [GlobalRdrElt]
old_gres =
case Unique -> ShadowedGREs -> IsShadowed
namespace_is_shadowed Unique
old_ns ShadowedGREs
shadowed_gres of
IsShadowed
IsNotShadowed -> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
forall a. a -> Maybe a
Just [GlobalRdrElt]
old_gres
IsShadowed
IsShadowed -> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
forall a. [a] -> Maybe [a]
guard_nonEmpty ([GlobalRdrElt] -> Maybe [GlobalRdrElt])
-> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
forall a b. (a -> b) -> a -> b
$ (GlobalRdrElt -> Maybe GlobalRdrElt)
-> [GlobalRdrElt] -> [GlobalRdrElt]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe GlobalRdrElt -> Maybe GlobalRdrElt
shadow [GlobalRdrElt]
old_gres
IsShadowed
IsShadowedIfFieldSelector ->
[GlobalRdrElt] -> Maybe [GlobalRdrElt]
forall a. [a] -> Maybe [a]
guard_nonEmpty ([GlobalRdrElt] -> Maybe [GlobalRdrElt])
-> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
forall a b. (a -> b) -> a -> b
$
(GlobalRdrElt -> Maybe GlobalRdrElt)
-> [GlobalRdrElt] -> [GlobalRdrElt]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (\ GlobalRdrElt
old_gre -> if GlobalRdrElt -> Bool
isFieldSelectorGRE GlobalRdrElt
old_gre then GlobalRdrElt -> Maybe GlobalRdrElt
shadow GlobalRdrElt
old_gre else GlobalRdrElt -> Maybe GlobalRdrElt
forall a. a -> Maybe a
Just GlobalRdrElt
old_gre)
[GlobalRdrElt]
old_gres
in (Unique -> [GlobalRdrElt] -> Maybe [GlobalRdrElt])
-> UniqFM NameSpace [GlobalRdrElt]
-> UniqFM NameSpace [GlobalRdrElt]
forall {k} elt1 elt2 (key :: k).
(Unique -> elt1 -> Maybe elt2)
-> UniqFM key elt1 -> UniqFM key elt2
mapMaybeWithKeyUFM Unique -> [GlobalRdrElt] -> Maybe [GlobalRdrElt]
shadow_list UniqFM NameSpace [GlobalRdrElt]
olds
guard_nonEmpty :: [a] -> Maybe [a]
guard_nonEmpty :: forall a. [a] -> Maybe [a]
guard_nonEmpty [a]
xs | [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
xs = Maybe [a]
forall a. Maybe a
Nothing
| Bool
otherwise = [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
xs
shadow :: GlobalRdrElt-> Maybe GlobalRdrElt
shadow :: GlobalRdrElt -> Maybe GlobalRdrElt
shadow old_gre :: GlobalRdrElt
old_gre@(GRE { gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss }) =
case GlobalRdrElt -> Maybe Module
forall info. GlobalRdrEltX info -> Maybe Module
greDefinitionModule GlobalRdrElt
old_gre of
Maybe Module
Nothing -> GlobalRdrElt -> Maybe GlobalRdrElt
forall a. a -> Maybe a
Just GlobalRdrElt
old_gre
Just Module
old_mod
| Bag ImportSpec -> Bool
forall a. Bag a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Bag ImportSpec
iss'
Bool -> Bool -> Bool
|| Bool
drop_only_qualified
-> Maybe GlobalRdrElt
forall a. Maybe a
Nothing
| Bool
otherwise
-> GlobalRdrElt -> Maybe GlobalRdrElt
forall a. a -> Maybe a
Just (GlobalRdrElt
old_gre { gre_lcl = False, gre_imp = iss' })
where
iss' :: Bag ImportSpec
iss' = Bag ImportSpec
lcl_imp Bag ImportSpec -> Bag ImportSpec -> Bag ImportSpec
forall a. Bag a -> Bag a -> Bag a
`unionBags` (ImportSpec -> ImportSpec) -> Bag ImportSpec -> Bag ImportSpec
forall a b. (a -> b) -> Bag a -> Bag b
mapBag ImportSpec -> ImportSpec
set_qual Bag ImportSpec
iss
lcl_imp :: Bag ImportSpec
lcl_imp | Bool
lcl = ImportSpec -> Bag ImportSpec
forall a. a -> Bag a
unitBag (ImportSpec -> Bag ImportSpec) -> ImportSpec -> Bag ImportSpec
forall a b. (a -> b) -> a -> b
$ GlobalRdrElt -> Module -> ImportSpec
forall {info}. GlobalRdrEltX info -> Module -> ImportSpec
mk_fake_imp_spec GlobalRdrElt
old_gre Module
old_mod
| Bool
otherwise = Bag ImportSpec
forall a. Bag a
emptyBag
mk_fake_imp_spec :: GlobalRdrEltX info -> Module -> ImportSpec
mk_fake_imp_spec GlobalRdrEltX info
old_gre Module
old_mod
= ImpDeclSpec -> ImpItemSpec -> ImportSpec
ImpSpec ImpDeclSpec
id_spec ImpItemSpec
ImpAll
where
old_mod_name :: ModuleName
old_mod_name = Module -> ModuleName
forall unit. GenModule unit -> ModuleName
moduleName Module
old_mod
id_spec :: ImpDeclSpec
id_spec = ImpDeclSpec { is_mod :: Module
is_mod = Module
old_mod
, is_as :: ModuleName
is_as = ModuleName
old_mod_name
, is_pkg_qual :: PkgQual
is_pkg_qual = PkgQual
NoPkgQual
, is_qual :: Bool
is_qual = Bool
True
, is_isboot :: IsBootInterface
is_isboot = IsBootInterface
NotBoot
, is_dloc :: SrcSpan
is_dloc = GlobalRdrEltX info -> SrcSpan
forall info. GlobalRdrEltX info -> SrcSpan
greDefinitionSrcSpan GlobalRdrEltX info
old_gre }
set_qual :: ImportSpec -> ImportSpec
set_qual :: ImportSpec -> ImportSpec
set_qual ImportSpec
is = ImportSpec
is { is_decl = (is_decl is) { is_qual = True } }
greClashesWith :: GlobalRdrElt -> (GlobalRdrElt -> Bool)
greClashesWith :: GlobalRdrElt -> GlobalRdrElt -> Bool
greClashesWith GlobalRdrElt
new_gre GlobalRdrElt
old_gre =
GlobalRdrElt
old_gre GlobalRdrElt -> ShadowedGREs -> Bool
`greIsShadowed` GlobalRdrElt -> ShadowedGREs
greShadowedNameSpaces GlobalRdrElt
new_gre
greIsShadowed :: GlobalRdrElt -> ShadowedGREs -> Bool
greIsShadowed :: GlobalRdrElt -> ShadowedGREs -> Bool
greIsShadowed GlobalRdrElt
old_gre ShadowedGREs
shadowed =
case NameSpace -> Unique
forall a. Uniquable a => a -> Unique
getUnique NameSpace
old_ns Unique -> ShadowedGREs -> IsShadowed
`namespace_is_shadowed` ShadowedGREs
shadowed of
IsShadowed
IsShadowed -> Bool
True
IsShadowed
IsNotShadowed -> Bool
False
IsShadowed
IsShadowedIfFieldSelector -> GlobalRdrElt -> Bool
isFieldSelectorGRE GlobalRdrElt
old_gre
where
old_ns :: NameSpace
old_ns = OccName -> NameSpace
occNameSpace (OccName -> NameSpace) -> OccName -> NameSpace
forall a b. (a -> b) -> a -> b
$ GlobalRdrElt -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName GlobalRdrElt
old_gre
data IsShadowed
= IsNotShadowed
| IsShadowed
| IsShadowedIfFieldSelector
namespace_is_shadowed :: Unique -> ShadowedGREs -> IsShadowed
namespace_is_shadowed :: Unique -> ShadowedGREs -> IsShadowed
namespace_is_shadowed Unique
old_ns (ShadowedGREs UniqSet NameSpace
shadowed_nonflds ShadowedFieldGREs
shadowed_flds)
| Unique -> Bool
isFldNSUnique Unique
old_ns
= case ShadowedFieldGREs
shadowed_flds of
ShadowedFieldGREs
ShadowAllFieldGREs -> IsShadowed
IsShadowed
ShadowFieldSelectorsAnd UniqSet NameSpace
shadowed
| Unique
old_ns Unique -> UniqSet NameSpace -> Bool
forall a. Unique -> UniqSet a -> Bool
`elemUniqSet_Directly` UniqSet NameSpace
shadowed
-> IsShadowed
IsShadowed
| Bool
otherwise
-> IsShadowed
IsShadowedIfFieldSelector
ShadowFieldNameSpaces UniqSet NameSpace
shadowed
| Unique
old_ns Unique -> UniqSet NameSpace -> Bool
forall a. Unique -> UniqSet a -> Bool
`elemUniqSet_Directly` UniqSet NameSpace
shadowed
-> IsShadowed
IsShadowed
| Bool
otherwise
-> IsShadowed
IsNotShadowed
| Unique
old_ns Unique -> UniqSet NameSpace -> Bool
forall a. Unique -> UniqSet a -> Bool
`elemUniqSet_Directly` UniqSet NameSpace
shadowed_nonflds
= IsShadowed
IsShadowed
| Bool
otherwise
= IsShadowed
IsNotShadowed
greShadowedNameSpaces :: GlobalRdrElt -> ShadowedGREs
greShadowedNameSpaces :: GlobalRdrElt -> ShadowedGREs
greShadowedNameSpaces GlobalRdrElt
gre = UniqSet NameSpace -> ShadowedFieldGREs -> ShadowedGREs
ShadowedGREs UniqSet NameSpace
shadowed_nonflds ShadowedFieldGREs
shadowed_flds
where
ns :: NameSpace
ns = OccName -> NameSpace
occNameSpace (OccName -> NameSpace) -> OccName -> NameSpace
forall a b. (a -> b) -> a -> b
$ GlobalRdrElt -> OccName
forall info. GlobalRdrEltX info -> OccName
greOccName GlobalRdrElt
gre
!shadowed_nonflds :: UniqSet NameSpace
shadowed_nonflds
| NameSpace -> Bool
isFieldNameSpace NameSpace
ns
= if GlobalRdrElt -> Bool
isFieldSelectorGRE GlobalRdrElt
gre
then NameSpace -> UniqSet NameSpace
forall a. Uniquable a => a -> UniqSet a
unitUniqSet NameSpace
varName
else UniqSet NameSpace
forall a. UniqSet a
emptyUniqSet
| Bool
otherwise
= NameSpace -> UniqSet NameSpace
forall a. Uniquable a => a -> UniqSet a
unitUniqSet NameSpace
ns
!shadowed_flds :: ShadowedFieldGREs
shadowed_flds
| NameSpace
ns NameSpace -> NameSpace -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace
varName
= UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldSelectorsAnd UniqSet NameSpace
forall a. UniqSet a
emptyUniqSet
| NameSpace -> Bool
isFieldNameSpace NameSpace
ns
= if GlobalRdrElt -> Bool
isDuplicateRecFldGRE GlobalRdrElt
gre
then UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldNameSpaces (NameSpace -> UniqSet NameSpace
forall a. Uniquable a => a -> UniqSet a
unitUniqSet NameSpace
ns)
else ShadowedFieldGREs
ShadowAllFieldGREs
| Bool
otherwise
= UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldNameSpaces UniqSet NameSpace
forall a. UniqSet a
emptyUniqSet
data ShadowedGREs
= ShadowedGREs
{ ShadowedGREs -> UniqSet NameSpace
shadowedNonFieldNameSpaces :: !(UniqSet NameSpace)
, ShadowedGREs -> ShadowedFieldGREs
shadowedFieldGREs :: !ShadowedFieldGREs
}
data ShadowedFieldGREs
= ShadowAllFieldGREs
| ShadowFieldSelectorsAnd { ShadowedFieldGREs -> UniqSet NameSpace
shadowedFieldNameSpaces :: !(UniqSet NameSpace) }
| ShadowFieldNameSpaces { shadowedFieldNameSpaces :: !(UniqSet NameSpace) }
instance Monoid ShadowedFieldGREs where
mempty :: ShadowedFieldGREs
mempty = ShadowFieldNameSpaces { shadowedFieldNameSpaces :: UniqSet NameSpace
shadowedFieldNameSpaces = UniqSet NameSpace
forall a. UniqSet a
emptyUniqSet }
instance Semigroup ShadowedFieldGREs where
ShadowedFieldGREs
ShadowAllFieldGREs <> :: ShadowedFieldGREs -> ShadowedFieldGREs -> ShadowedFieldGREs
<> ShadowedFieldGREs
_ = ShadowedFieldGREs
ShadowAllFieldGREs
ShadowedFieldGREs
_ <> ShadowedFieldGREs
ShadowAllFieldGREs = ShadowedFieldGREs
ShadowAllFieldGREs
ShadowFieldSelectorsAnd UniqSet NameSpace
ns1 <> ShadowFieldSelectorsAnd UniqSet NameSpace
ns2 =
UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldSelectorsAnd (UniqSet NameSpace
ns1 UniqSet NameSpace -> UniqSet NameSpace -> UniqSet NameSpace
forall a. Semigroup a => a -> a -> a
S.<> UniqSet NameSpace
ns2)
ShadowFieldSelectorsAnd UniqSet NameSpace
ns1 <> ShadowFieldNameSpaces UniqSet NameSpace
ns2 =
UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldSelectorsAnd (UniqSet NameSpace
ns1 UniqSet NameSpace -> UniqSet NameSpace -> UniqSet NameSpace
forall a. Semigroup a => a -> a -> a
S.<> UniqSet NameSpace
ns2)
ShadowFieldNameSpaces UniqSet NameSpace
ns1 <> ShadowFieldSelectorsAnd UniqSet NameSpace
ns2 =
UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldSelectorsAnd (UniqSet NameSpace
ns1 UniqSet NameSpace -> UniqSet NameSpace -> UniqSet NameSpace
forall a. Semigroup a => a -> a -> a
S.<> UniqSet NameSpace
ns2)
ShadowFieldNameSpaces UniqSet NameSpace
ns1 <> ShadowFieldNameSpaces UniqSet NameSpace
ns2 =
UniqSet NameSpace -> ShadowedFieldGREs
ShadowFieldNameSpaces (UniqSet NameSpace
ns1 UniqSet NameSpace -> UniqSet NameSpace -> UniqSet NameSpace
forall a. Semigroup a => a -> a -> a
S.<> UniqSet NameSpace
ns2)
instance Monoid ShadowedGREs where
mempty :: ShadowedGREs
mempty =
ShadowedGREs
{ shadowedNonFieldNameSpaces :: UniqSet NameSpace
shadowedNonFieldNameSpaces = UniqSet NameSpace
forall a. UniqSet a
emptyUniqSet
, shadowedFieldGREs :: ShadowedFieldGREs
shadowedFieldGREs = ShadowedFieldGREs
forall a. Monoid a => a
mempty }
instance Semigroup ShadowedGREs where
ShadowedGREs UniqSet NameSpace
nonflds1 ShadowedFieldGREs
flds1 <> :: ShadowedGREs -> ShadowedGREs -> ShadowedGREs
<> ShadowedGREs UniqSet NameSpace
nonflds2 ShadowedFieldGREs
flds2 =
UniqSet NameSpace -> ShadowedFieldGREs -> ShadowedGREs
ShadowedGREs (UniqSet NameSpace
nonflds1 UniqSet NameSpace -> UniqSet NameSpace -> UniqSet NameSpace
forall a. Semigroup a => a -> a -> a
S.<> UniqSet NameSpace
nonflds2) (ShadowedFieldGREs
flds1 ShadowedFieldGREs -> ShadowedFieldGREs -> ShadowedFieldGREs
forall a. Semigroup a => a -> a -> a
S.<> ShadowedFieldGREs
flds2)
data ImportSpec = ImpSpec { ImportSpec -> ImpDeclSpec
is_decl :: !ImpDeclSpec,
ImportSpec -> ImpItemSpec
is_item :: !ImpItemSpec }
deriving( ImportSpec -> ImportSpec -> Bool
(ImportSpec -> ImportSpec -> Bool)
-> (ImportSpec -> ImportSpec -> Bool) -> Eq ImportSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportSpec -> ImportSpec -> Bool
== :: ImportSpec -> ImportSpec -> Bool
$c/= :: ImportSpec -> ImportSpec -> Bool
/= :: ImportSpec -> ImportSpec -> Bool
Eq, Typeable ImportSpec
Typeable ImportSpec =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec -> c ImportSpec)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportSpec)
-> (ImportSpec -> Constr)
-> (ImportSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportSpec))
-> ((forall b. Data b => b -> b) -> ImportSpec -> ImportSpec)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImportSpec -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ImportSpec -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec)
-> Data ImportSpec
ImportSpec -> Constr
ImportSpec -> DataType
(forall b. Data b => b -> b) -> ImportSpec -> ImportSpec
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec -> u
forall u. (forall d. Data d => d -> u) -> ImportSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec -> c ImportSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec -> c ImportSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportSpec -> c ImportSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportSpec
$ctoConstr :: ImportSpec -> Constr
toConstr :: ImportSpec -> Constr
$cdataTypeOf :: ImportSpec -> DataType
dataTypeOf :: ImportSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec)
$cgmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec
gmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec
Data )
instance NFData ImportSpec where
rnf :: ImportSpec -> ()
rnf = ImportSpec -> ()
forall a. a -> ()
rwhnf
data ImpDeclSpec
= ImpDeclSpec {
ImpDeclSpec -> Module
is_mod :: !Module,
ImpDeclSpec -> ModuleName
is_as :: !ModuleName,
ImpDeclSpec -> PkgQual
is_pkg_qual :: !PkgQual,
ImpDeclSpec -> Bool
is_qual :: !Bool,
ImpDeclSpec -> SrcSpan
is_dloc :: !SrcSpan,
ImpDeclSpec -> IsBootInterface
is_isboot :: !IsBootInterface
} deriving (ImpDeclSpec -> ImpDeclSpec -> Bool
(ImpDeclSpec -> ImpDeclSpec -> Bool)
-> (ImpDeclSpec -> ImpDeclSpec -> Bool) -> Eq ImpDeclSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImpDeclSpec -> ImpDeclSpec -> Bool
== :: ImpDeclSpec -> ImpDeclSpec -> Bool
$c/= :: ImpDeclSpec -> ImpDeclSpec -> Bool
/= :: ImpDeclSpec -> ImpDeclSpec -> Bool
Eq, Typeable ImpDeclSpec
Typeable ImpDeclSpec =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpDeclSpec)
-> (ImpDeclSpec -> Constr)
-> (ImpDeclSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpDeclSpec))
-> ((forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImpDeclSpec -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec)
-> Data ImpDeclSpec
ImpDeclSpec -> Constr
ImpDeclSpec -> DataType
(forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u
forall u. (forall d. Data d => d -> u) -> ImpDeclSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpDeclSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpDeclSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpDeclSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpDeclSpec
$ctoConstr :: ImpDeclSpec -> Constr
toConstr :: ImpDeclSpec -> Constr
$cdataTypeOf :: ImpDeclSpec -> DataType
dataTypeOf :: ImpDeclSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpDeclSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpDeclSpec)
$cgmapT :: (forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec
gmapT :: (forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImpDeclSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImpDeclSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec
Data)
instance NFData ImpDeclSpec where
rnf :: ImpDeclSpec -> ()
rnf = ImpDeclSpec -> ()
forall a. a -> ()
rwhnf
instance Binary ImpDeclSpec where
put_ :: WriteBinHandle -> ImpDeclSpec -> IO ()
put_ WriteBinHandle
bh (ImpDeclSpec Module
mod ModuleName
as PkgQual
pkg_qual Bool
qual SrcSpan
_dloc IsBootInterface
isboot) = do
WriteBinHandle -> Module -> IO ()
forall a. Binary a => WriteBinHandle -> a -> IO ()
put_ WriteBinHandle
bh Module
mod
WriteBinHandle -> ModuleName -> IO ()
forall a. Binary a => WriteBinHandle -> a -> IO ()
put_ WriteBinHandle
bh ModuleName
as
WriteBinHandle -> PkgQual -> IO ()
forall a. Binary a => WriteBinHandle -> a -> IO ()
put_ WriteBinHandle
bh PkgQual
pkg_qual
WriteBinHandle -> Bool -> IO ()
forall a. Binary a => WriteBinHandle -> a -> IO ()
put_ WriteBinHandle
bh Bool
qual
WriteBinHandle -> IsBootInterface -> IO ()
forall a. Binary a => WriteBinHandle -> a -> IO ()
put_ WriteBinHandle
bh IsBootInterface
isboot
get :: ReadBinHandle -> IO ImpDeclSpec
get ReadBinHandle
bh = do
mod <- ReadBinHandle -> IO Module
forall a. Binary a => ReadBinHandle -> IO a
get ReadBinHandle
bh
as <- get bh
pkg_qual <- get bh
qual <- get bh
isboot <- get bh
return (ImpDeclSpec mod as pkg_qual qual noSrcSpan isboot)
data ImpItemSpec
= ImpAll
| ImpSome {
ImpItemSpec -> Bool
is_explicit :: !Bool,
ImpItemSpec -> SrcSpan
is_iloc :: !SrcSpan
}
deriving (ImpItemSpec -> ImpItemSpec -> Bool
(ImpItemSpec -> ImpItemSpec -> Bool)
-> (ImpItemSpec -> ImpItemSpec -> Bool) -> Eq ImpItemSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImpItemSpec -> ImpItemSpec -> Bool
== :: ImpItemSpec -> ImpItemSpec -> Bool
$c/= :: ImpItemSpec -> ImpItemSpec -> Bool
/= :: ImpItemSpec -> ImpItemSpec -> Bool
Eq, Typeable ImpItemSpec
Typeable ImpItemSpec =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpItemSpec)
-> (ImpItemSpec -> Constr)
-> (ImpItemSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpItemSpec))
-> ((forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImpItemSpec -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec)
-> Data ImpItemSpec
ImpItemSpec -> Constr
ImpItemSpec -> DataType
(forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u
forall u. (forall d. Data d => d -> u) -> ImpItemSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpItemSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpItemSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpItemSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImpItemSpec
$ctoConstr :: ImpItemSpec -> Constr
toConstr :: ImpItemSpec -> Constr
$cdataTypeOf :: ImpItemSpec -> DataType
dataTypeOf :: ImpItemSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpItemSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImpItemSpec)
$cgmapT :: (forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec
gmapT :: (forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImpItemSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImpItemSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec
Data)
bestImport :: NE.NonEmpty ImportSpec -> ImportSpec
bestImport :: NonEmpty ImportSpec -> ImportSpec
bestImport NonEmpty ImportSpec
iss = NonEmpty ImportSpec -> ImportSpec
forall a. NonEmpty a -> a
NE.head (NonEmpty ImportSpec -> ImportSpec)
-> NonEmpty ImportSpec -> ImportSpec
forall a b. (a -> b) -> a -> b
$ (ImportSpec -> ImportSpec -> Ordering)
-> NonEmpty ImportSpec -> NonEmpty ImportSpec
forall a. (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
NE.sortBy ImportSpec -> ImportSpec -> Ordering
best NonEmpty ImportSpec
iss
where
best :: ImportSpec -> ImportSpec -> Ordering
best :: ImportSpec -> ImportSpec -> Ordering
best (ImpSpec { is_item :: ImportSpec -> ImpItemSpec
is_item = ImpItemSpec
item1, is_decl :: ImportSpec -> ImpDeclSpec
is_decl = ImpDeclSpec
d1 })
(ImpSpec { is_item :: ImportSpec -> ImpItemSpec
is_item = ImpItemSpec
item2, is_decl :: ImportSpec -> ImpDeclSpec
is_decl = ImpDeclSpec
d2 })
= (ImpDeclSpec -> Bool
is_qual ImpDeclSpec
d1 Bool -> Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` ImpDeclSpec -> Bool
is_qual ImpDeclSpec
d2) Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
S.<> ImpItemSpec -> ImpItemSpec -> Ordering
best_item ImpItemSpec
item1 ImpItemSpec
item2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
S.<>
SrcSpan -> SrcSpan -> Ordering
SrcLoc.leftmost_smallest (ImpDeclSpec -> SrcSpan
is_dloc ImpDeclSpec
d1) (ImpDeclSpec -> SrcSpan
is_dloc ImpDeclSpec
d2)
best_item :: ImpItemSpec -> ImpItemSpec -> Ordering
best_item :: ImpItemSpec -> ImpItemSpec -> Ordering
best_item ImpItemSpec
ImpAll ImpItemSpec
ImpAll = Ordering
EQ
best_item ImpItemSpec
ImpAll (ImpSome {}) = Ordering
LT
best_item (ImpSome {}) ImpItemSpec
ImpAll = Ordering
GT
best_item (ImpSome { is_explicit :: ImpItemSpec -> Bool
is_explicit = Bool
e1 })
(ImpSome { is_explicit :: ImpItemSpec -> Bool
is_explicit = Bool
e2 }) = Bool
e1 Bool -> Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Bool
e2
unQualSpecOK :: ImportSpec -> Bool
unQualSpecOK :: ImportSpec -> Bool
unQualSpecOK ImportSpec
is = Bool -> Bool
not (ImpDeclSpec -> Bool
is_qual (ImportSpec -> ImpDeclSpec
is_decl ImportSpec
is))
qualSpecOK :: ModuleName -> ImportSpec -> Bool
qualSpecOK :: ModuleName -> ImportSpec -> Bool
qualSpecOK ModuleName
mod ImportSpec
is = ModuleName
mod ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
== ImpDeclSpec -> ModuleName
is_as (ImportSpec -> ImpDeclSpec
is_decl ImportSpec
is)
importSpecLoc :: ImportSpec -> SrcSpan
importSpecLoc :: ImportSpec -> SrcSpan
importSpecLoc (ImpSpec ImpDeclSpec
decl ImpItemSpec
ImpAll) = ImpDeclSpec -> SrcSpan
is_dloc ImpDeclSpec
decl
importSpecLoc (ImpSpec ImpDeclSpec
_ ImpItemSpec
item) = ImpItemSpec -> SrcSpan
is_iloc ImpItemSpec
item
importSpecModule :: ImportSpec -> ModuleName
importSpecModule :: ImportSpec -> ModuleName
importSpecModule = Module -> ModuleName
forall unit. GenModule unit -> ModuleName
moduleName (Module -> ModuleName)
-> (ImportSpec -> Module) -> ImportSpec -> ModuleName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImpDeclSpec -> Module
is_mod (ImpDeclSpec -> Module)
-> (ImportSpec -> ImpDeclSpec) -> ImportSpec -> Module
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ImportSpec -> ImpDeclSpec
is_decl
isExplicitItem :: ImpItemSpec -> Bool
isExplicitItem :: ImpItemSpec -> Bool
isExplicitItem ImpItemSpec
ImpAll = Bool
False
isExplicitItem (ImpSome {is_explicit :: ImpItemSpec -> Bool
is_explicit = Bool
exp}) = Bool
exp
pprNameProvenance :: GlobalRdrEltX info -> SDoc
pprNameProvenance :: forall info. GlobalRdrEltX info -> SDoc
pprNameProvenance (GRE { gre_name :: forall info. GlobalRdrEltX info -> Name
gre_name = Name
name, gre_lcl :: forall info. GlobalRdrEltX info -> Bool
gre_lcl = Bool
lcl, gre_imp :: forall info. GlobalRdrEltX info -> Bag ImportSpec
gre_imp = Bag ImportSpec
iss })
= SDoc -> SDoc -> SDoc
forall doc. IsOutput doc => doc -> doc -> doc
ifPprDebug ([SDoc] -> SDoc
forall doc. IsDoc doc => [doc] -> doc
vcat [SDoc]
pp_provs)
([SDoc] -> SDoc
forall a. HasCallStack => [a] -> a
head [SDoc]
pp_provs)
where
pp_provs :: [SDoc]
pp_provs = [SDoc]
pp_lcl [SDoc] -> [SDoc] -> [SDoc]
forall a. [a] -> [a] -> [a]
++ (ImportSpec -> SDoc) -> [ImportSpec] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map ImportSpec -> SDoc
pp_is (Bag ImportSpec -> [ImportSpec]
forall a. Bag a -> [a]
bagToList Bag ImportSpec
iss)
pp_lcl :: [SDoc]
pp_lcl = if Bool
lcl then [String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"defined at" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SrcLoc -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Name -> SrcLoc
nameSrcLoc Name
name)]
else []
pp_is :: ImportSpec -> SDoc
pp_is ImportSpec
is = [SDoc] -> SDoc
forall doc. IsLine doc => [doc] -> doc
sep [ImportSpec -> SDoc
forall a. Outputable a => a -> SDoc
ppr ImportSpec
is, ImportSpec -> Name -> SDoc
ppr_defn_site ImportSpec
is Name
name]
ppr_defn_site :: ImportSpec -> Name -> SDoc
ppr_defn_site :: ImportSpec -> Name -> SDoc
ppr_defn_site ImportSpec
imp_spec Name
name
| Bool
same_module Bool -> Bool -> Bool
&& Bool -> Bool
not (SrcSpan -> Bool
isGoodSrcSpan SrcSpan
loc)
= SDoc
forall doc. IsOutput doc => doc
empty
| Bool
otherwise
= SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
parens (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"and originally defined" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
pp_mod)
Int
2 (SrcSpan -> SDoc
pprLoc SrcSpan
loc)
where
loc :: SrcSpan
loc = Name -> SrcSpan
nameSrcSpan Name
name
defining_mod :: Module
defining_mod = Bool -> SDoc -> Module -> Module
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Name -> Bool
isExternalName Name
name) (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name) (Module -> Module) -> Module -> Module
forall a b. (a -> b) -> a -> b
$ HasDebugCallStack => Name -> Module
Name -> Module
nameModule Name
name
same_module :: Bool
same_module = ImportSpec -> ModuleName
importSpecModule ImportSpec
imp_spec ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
== Module -> ModuleName
forall unit. GenModule unit -> ModuleName
moduleName Module
defining_mod
pp_mod :: SDoc
pp_mod | Bool
same_module = SDoc
forall doc. IsOutput doc => doc
empty
| Bool
otherwise = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"in" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc -> SDoc
quotes (Module -> SDoc
forall a. Outputable a => a -> SDoc
ppr Module
defining_mod)
instance Outputable ImportSpec where
ppr :: ImportSpec -> SDoc
ppr ImportSpec
imp_spec
= String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"imported" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
qual
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"from" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc -> SDoc
quotes (ModuleName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (ImportSpec -> ModuleName
importSpecModule ImportSpec
imp_spec))
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SrcSpan -> SDoc
pprLoc (ImportSpec -> SrcSpan
importSpecLoc ImportSpec
imp_spec)
where
qual :: SDoc
qual | ImpDeclSpec -> Bool
is_qual (ImportSpec -> ImpDeclSpec
is_decl ImportSpec
imp_spec) = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"qualified"
| Bool
otherwise = SDoc
forall doc. IsOutput doc => doc
empty
pprLoc :: SrcSpan -> SDoc
pprLoc :: SrcSpan -> SDoc
pprLoc (RealSrcSpan RealSrcSpan
s Maybe BufSpan
_) = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"at" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> RealSrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr RealSrcSpan
s
pprLoc (UnhelpfulSpan {}) = SDoc
forall doc. IsOutput doc => doc
empty
opIsAt :: RdrName -> Bool
opIsAt :: RdrName -> Bool
opIsAt RdrName
e = RdrName
e RdrName -> RdrName -> Bool
forall a. Eq a => a -> a -> Bool
== NameSpace -> FastString -> RdrName
mkUnqual NameSpace
varName (String -> FastString
fsLit String
"@")
data WithUserRdr a = WithUserRdr RdrName a
deriving stock ((forall a b. (a -> b) -> WithUserRdr a -> WithUserRdr b)
-> (forall a b. a -> WithUserRdr b -> WithUserRdr a)
-> Functor WithUserRdr
forall a b. a -> WithUserRdr b -> WithUserRdr a
forall a b. (a -> b) -> WithUserRdr a -> WithUserRdr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> WithUserRdr a -> WithUserRdr b
fmap :: forall a b. (a -> b) -> WithUserRdr a -> WithUserRdr b
$c<$ :: forall a b. a -> WithUserRdr b -> WithUserRdr a
<$ :: forall a b. a -> WithUserRdr b -> WithUserRdr a
Functor, (forall m. Monoid m => WithUserRdr m -> m)
-> (forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m)
-> (forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m)
-> (forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b)
-> (forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b)
-> (forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b)
-> (forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b)
-> (forall a. (a -> a -> a) -> WithUserRdr a -> a)
-> (forall a. (a -> a -> a) -> WithUserRdr a -> a)
-> (forall a. WithUserRdr a -> [a])
-> (forall a. WithUserRdr a -> Bool)
-> (forall a. WithUserRdr a -> Int)
-> (forall a. Eq a => a -> WithUserRdr a -> Bool)
-> (forall a. Ord a => WithUserRdr a -> a)
-> (forall a. Ord a => WithUserRdr a -> a)
-> (forall a. Num a => WithUserRdr a -> a)
-> (forall a. Num a => WithUserRdr a -> a)
-> Foldable WithUserRdr
forall a. Eq a => a -> WithUserRdr a -> Bool
forall a. Num a => WithUserRdr a -> a
forall a. Ord a => WithUserRdr a -> a
forall m. Monoid m => WithUserRdr m -> m
forall a. WithUserRdr a -> Bool
forall a. WithUserRdr a -> Int
forall a. WithUserRdr a -> [a]
forall a. (a -> a -> a) -> WithUserRdr a -> a
forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m
forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b
forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => WithUserRdr m -> m
fold :: forall m. Monoid m => WithUserRdr m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> WithUserRdr a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WithUserRdr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> WithUserRdr a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> WithUserRdr a -> a
foldr1 :: forall a. (a -> a -> a) -> WithUserRdr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> WithUserRdr a -> a
foldl1 :: forall a. (a -> a -> a) -> WithUserRdr a -> a
$ctoList :: forall a. WithUserRdr a -> [a]
toList :: forall a. WithUserRdr a -> [a]
$cnull :: forall a. WithUserRdr a -> Bool
null :: forall a. WithUserRdr a -> Bool
$clength :: forall a. WithUserRdr a -> Int
length :: forall a. WithUserRdr a -> Int
$celem :: forall a. Eq a => a -> WithUserRdr a -> Bool
elem :: forall a. Eq a => a -> WithUserRdr a -> Bool
$cmaximum :: forall a. Ord a => WithUserRdr a -> a
maximum :: forall a. Ord a => WithUserRdr a -> a
$cminimum :: forall a. Ord a => WithUserRdr a -> a
minimum :: forall a. Ord a => WithUserRdr a -> a
$csum :: forall a. Num a => WithUserRdr a -> a
sum :: forall a. Num a => WithUserRdr a -> a
$cproduct :: forall a. Num a => WithUserRdr a -> a
product :: forall a. Num a => WithUserRdr a -> a
Foldable, Functor WithUserRdr
Foldable WithUserRdr
(Functor WithUserRdr, Foldable WithUserRdr) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithUserRdr a -> f (WithUserRdr b))
-> (forall (f :: * -> *) a.
Applicative f =>
WithUserRdr (f a) -> f (WithUserRdr a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithUserRdr a -> m (WithUserRdr b))
-> (forall (m :: * -> *) a.
Monad m =>
WithUserRdr (m a) -> m (WithUserRdr a))
-> Traversable WithUserRdr
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
WithUserRdr (m a) -> m (WithUserRdr a)
forall (f :: * -> *) a.
Applicative f =>
WithUserRdr (f a) -> f (WithUserRdr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithUserRdr a -> m (WithUserRdr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithUserRdr a -> f (WithUserRdr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithUserRdr a -> f (WithUserRdr b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WithUserRdr a -> f (WithUserRdr b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithUserRdr (f a) -> f (WithUserRdr a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
WithUserRdr (f a) -> f (WithUserRdr a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithUserRdr a -> m (WithUserRdr b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> WithUserRdr a -> m (WithUserRdr b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
WithUserRdr (m a) -> m (WithUserRdr a)
sequence :: forall (m :: * -> *) a.
Monad m =>
WithUserRdr (m a) -> m (WithUserRdr a)
Traversable)
instance NamedThing a => NamedThing (WithUserRdr a) where
getName :: WithUserRdr a -> Name
getName (WithUserRdr RdrName
_rdr a
a) = a -> Name
forall a. NamedThing a => a -> Name
getName a
a
instance Outputable (WithUserRdr Name) where
ppr :: WithUserRdr Name -> SDoc
ppr (WithUserRdr RdrName
rdr Name
name) =
Maybe ModuleName -> Name -> SDoc
forall doc. IsLine doc => Maybe ModuleName -> Name -> doc
pprName_userQual (RdrName -> Maybe ModuleName
rdrQual_maybe RdrName
rdr) Name
name
instance OutputableBndr (WithUserRdr Name) where
pprBndr :: BindingSite -> WithUserRdr Name -> SDoc
pprBndr BindingSite
_ (WithUserRdr RdrName
rdr Name
name) =
Maybe ModuleName -> Name -> SDoc
forall doc. IsLine doc => Maybe ModuleName -> Name -> doc
pprName_userQual (RdrName -> Maybe ModuleName
rdrQual_maybe RdrName
rdr) Name
name
pprInfixOcc :: WithUserRdr Name -> SDoc
pprInfixOcc :: WithUserRdr Name -> SDoc
pprInfixOcc = WithUserRdr Name -> SDoc
forall a. (Outputable a, NamedThing a) => a -> SDoc
pprInfixName
pprPrefixOcc :: WithUserRdr Name -> SDoc
pprPrefixOcc = WithUserRdr Name -> SDoc
forall a. (Outputable a, NamedThing a) => a -> SDoc
pprPrefixName
unLocWithUserRdr :: GenLocated l (WithUserRdr a) -> a
unLocWithUserRdr :: forall l a. GenLocated l (WithUserRdr a) -> a
unLocWithUserRdr (L l
_ (WithUserRdr RdrName
_ a
a)) = a
a
noUserRdr :: Name -> WithUserRdr Name
noUserRdr :: Name -> WithUserRdr Name
noUserRdr Name
n = RdrName -> Name -> WithUserRdr Name
forall a. RdrName -> a -> WithUserRdr a
WithUserRdr (Name -> RdrName
nameRdrName Name
n) Name
n
rdrQual_maybe :: RdrName -> Maybe ModuleName
rdrQual_maybe :: RdrName -> Maybe ModuleName
rdrQual_maybe = \case
Qual ModuleName
q OccName
_ -> ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
q
RdrName
_ -> Maybe ModuleName
forall a. Maybe a
Nothing