{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
module GHC.Tc.Gen.Export (rnExports, exports_from_avail) where
import GHC.Prelude
import GHC.Hs
import GHC.Types.FieldLabel
import GHC.Builtin.Names
import GHC.Tc.Errors.Types
import GHC.Tc.Utils.Monad
import GHC.Tc.Utils.Env
import GHC.Tc.Utils.TcType
import GHC.Rename.Names
import GHC.Rename.Env
import GHC.Rename.Unbound ( reportUnboundName )
import GHC.Utils.Error
import GHC.Unit.Module
import GHC.Unit.Module.Imported
import GHC.Core.TyCon
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Core.ConLike
import GHC.Core.PatSyn
import GHC.Data.Maybe
import GHC.Data.FastString (fsLit)
import GHC.Driver.Env
import GHC.Types.Unique.Set
import GHC.Types.SrcLoc as SrcLoc
import GHC.Types.Name
import GHC.Types.Name.Env
import GHC.Types.Name.Set
import GHC.Types.Avail
import GHC.Types.SourceFile
import GHC.Types.Id
import GHC.Types.Id.Info
import GHC.Types.Name.Reader
import Control.Monad
import GHC.Driver.Session
import GHC.Parser.PostProcess ( setRdrNameSpace )
import Data.Either ( partitionEithers )
import GHC.Rename.Doc
data ExportAccum
= ExportAccum
ExportOccMap
(UniqSet ModuleName)
emptyExportAccum :: ExportAccum
emptyExportAccum :: ExportAccum
emptyExportAccum = ExportOccMap -> UniqSet ModuleName -> ExportAccum
ExportAccum forall a. OccEnv a
emptyOccEnv forall a. UniqSet a
emptyUniqSet
accumExports :: (ExportAccum -> x -> TcRn (Maybe (ExportAccum, y)))
-> [x]
-> TcRn [y]
accumExports :: forall x y.
(ExportAccum -> x -> TcRn (Maybe (ExportAccum, y)))
-> [x] -> TcRn [y]
accumExports ExportAccum -> x -> TcRn (Maybe (ExportAccum, y))
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. [Maybe a] -> [a]
catMaybes forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) acc x y.
Monad m =>
(acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])
mapAccumLM ExportAccum
-> x -> IOEnv (Env TcGblEnv TcLclEnv) (ExportAccum, Maybe y)
f' ExportAccum
emptyExportAccum
where f' :: ExportAccum
-> x -> IOEnv (Env TcGblEnv TcLclEnv) (ExportAccum, Maybe y)
f' ExportAccum
acc x
x = do
Maybe (Maybe (ExportAccum, y))
m <- forall r. TcRn r -> TcRn (Maybe r)
attemptM (ExportAccum -> x -> TcRn (Maybe (ExportAccum, y))
f ExportAccum
acc x
x)
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ case Maybe (Maybe (ExportAccum, y))
m of
Just (Just (ExportAccum
acc', y
y)) -> (ExportAccum
acc', forall a. a -> Maybe a
Just y
y)
Maybe (Maybe (ExportAccum, y))
_ -> (ExportAccum
acc, forall a. Maybe a
Nothing)
type ExportOccMap = OccEnv (GreName, IE GhcPs)
rnExports :: Bool
-> Maybe (LocatedL [LIE GhcPs])
-> RnM TcGblEnv
rnExports :: Bool -> Maybe (LocatedL [LIE GhcPs]) -> RnM TcGblEnv
rnExports Bool
explicit_mod Maybe (LocatedL [LIE GhcPs])
exports
= forall r. TcM r -> TcM r
checkNoErrs forall a b. (a -> b) -> a -> b
$
forall gbl lcl a.
WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
unsetWOptM WarningFlag
Opt_WarnWarningsDeprecations forall a b. (a -> b) -> a -> b
$
do { HscEnv
hsc_env <- forall gbl lcl. TcRnIf gbl lcl HscEnv
getTopEnv
; TcGblEnv
tcg_env <- forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
; let dflags :: DynFlags
dflags = HscEnv -> DynFlags
hsc_dflags HscEnv
hsc_env
TcGblEnv { tcg_mod :: TcGblEnv -> Module
tcg_mod = Module
this_mod
, tcg_rdr_env :: TcGblEnv -> GlobalRdrEnv
tcg_rdr_env = GlobalRdrEnv
rdr_env
, tcg_imports :: TcGblEnv -> ImportAvails
tcg_imports = ImportAvails
imports
, tcg_src :: TcGblEnv -> HscSource
tcg_src = HscSource
hsc_src } = TcGblEnv
tcg_env
default_main :: RdrName
default_main | HomeUnitEnv -> Module
mainModIs (HscEnv -> HomeUnitEnv
hsc_HUE HscEnv
hsc_env) forall a. Eq a => a -> a -> Bool
== Module
this_mod
, Just String
main_fun <- DynFlags -> Maybe String
mainFunIs DynFlags
dflags
= NameSpace -> FastString -> RdrName
mkUnqual NameSpace
varName (String -> FastString
fsLit String
main_fun)
| Bool
otherwise
= RdrName
main_RDR_Unqual
; Bool
has_main <- (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Bool
null) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RdrName -> RnM [Name]
lookupInfoOccRn RdrName
default_main
; let real_exports :: Maybe (LocatedL [LIE GhcPs])
real_exports
| Bool
explicit_mod = Maybe (LocatedL [LIE GhcPs])
exports
| Bool
has_main
= forall a. a -> Maybe a
Just (forall a an. a -> LocatedAn an a
noLocA [forall a an. a -> LocatedAn an a
noLocA (forall pass. XIEVar pass -> LIEWrappedName (IdP pass) -> IE pass
IEVar NoExtField
noExtField
(forall a an. a -> LocatedAn an a
noLocA (forall name. LocatedN name -> IEWrappedName name
IEName forall a b. (a -> b) -> a -> b
$ forall a an. a -> LocatedAn an a
noLocA RdrName
default_main)))])
| Bool
otherwise = forall a. Maybe a
Nothing
; let do_it :: RnM (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo])
do_it = Maybe (LocatedL [LIE GhcPs])
-> GlobalRdrEnv
-> ImportAvails
-> Module
-> RnM (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo])
exports_from_avail Maybe (LocatedL [LIE GhcPs])
real_exports GlobalRdrEnv
rdr_env ImportAvails
imports Module
this_mod
; (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
rn_exports, [AvailInfo]
final_avails)
<- if HscSource
hsc_src forall a. Eq a => a -> a -> Bool
== HscSource
HsigFile
then do (Maybe
(Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
[AvailInfo])
mb_r, Messages TcRnMessage
msgs) <- forall a. TcRn a -> TcRn (Maybe a, Messages TcRnMessage)
tryTc RnM (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo])
do_it
case Maybe
(Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
[AvailInfo])
mb_r of
Just (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
[AvailInfo])
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
[AvailInfo])
r
Maybe
(Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])],
[AvailInfo])
Nothing -> Messages TcRnMessage -> TcRn ()
addMessages Messages TcRnMessage
msgs forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall env a. IOEnv env a
failM
else forall r. TcM r -> TcM r
checkNoErrs RnM (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo])
do_it
; let final_ns :: NameSet
final_ns = [AvailInfo] -> NameSet
availsToNameSetWithSelectors [AvailInfo]
final_avails
; String -> SDoc -> TcRn ()
traceRn String
"rnExports: Exports:" (forall a. Outputable a => a -> SDoc
ppr [AvailInfo]
final_avails)
; forall (m :: * -> *) a. Monad m => a -> m a
return (TcGblEnv
tcg_env { tcg_exports :: [AvailInfo]
tcg_exports = [AvailInfo]
final_avails
, tcg_rn_exports :: Maybe [(LIE GhcRn, [AvailInfo])]
tcg_rn_exports = case TcGblEnv -> Maybe [(LIE GhcRn, [AvailInfo])]
tcg_rn_exports TcGblEnv
tcg_env of
Maybe [(LIE GhcRn, [AvailInfo])]
Nothing -> forall a. Maybe a
Nothing
Just [(LIE GhcRn, [AvailInfo])]
_ -> Maybe [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
rn_exports
, tcg_dus :: DefUses
tcg_dus = TcGblEnv -> DefUses
tcg_dus TcGblEnv
tcg_env DefUses -> DefUses -> DefUses
`plusDU`
NameSet -> DefUses
usesOnly NameSet
final_ns }) }
exports_from_avail :: Maybe (LocatedL [LIE GhcPs])
-> GlobalRdrEnv
-> ImportAvails
-> Module
-> RnM (Maybe [(LIE GhcRn, Avails)], Avails)
exports_from_avail :: Maybe (LocatedL [LIE GhcPs])
-> GlobalRdrEnv
-> ImportAvails
-> Module
-> RnM (Maybe [(LIE GhcRn, [AvailInfo])], [AvailInfo])
exports_from_avail Maybe (LocatedL [LIE GhcPs])
Nothing GlobalRdrEnv
rdr_env ImportAvails
_imports Module
_this_mod
= do {
; TcRnMessage -> TcRn ()
addDiagnostic
(ModuleName -> TcRnMessage
TcRnMissingExportList forall a b. (a -> b) -> a -> b
$ forall unit. GenModule unit -> ModuleName
moduleName Module
_this_mod)
; let avails :: [AvailInfo]
avails =
forall a b. (a -> b) -> [a] -> [b]
map AvailInfo -> AvailInfo
fix_faminst forall b c a. (b -> c) -> (a -> b) -> a -> c
. [GlobalRdrElt] -> [AvailInfo]
gresToAvailInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter GlobalRdrElt -> Bool
isLocalGRE forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrEnv -> [GlobalRdrElt]
globalRdrEnvElts forall a b. (a -> b) -> a -> b
$ GlobalRdrEnv
rdr_env
; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Maybe a
Nothing, [AvailInfo]
avails) }
where
fix_faminst :: AvailInfo -> AvailInfo
fix_faminst avail :: AvailInfo
avail@(AvailTC Name
n [GreName]
ns)
| AvailInfo -> Bool
availExportsDecl AvailInfo
avail = AvailInfo
avail
| Bool
otherwise = Name -> [GreName] -> AvailInfo
AvailTC Name
n (Name -> GreName
NormalGreName Name
nforall a. a -> [a] -> [a]
:[GreName]
ns)
fix_faminst AvailInfo
avail = AvailInfo
avail
exports_from_avail (Just (L SrcSpanAnnL
_ [LIE GhcPs]
rdr_items)) GlobalRdrEnv
rdr_env ImportAvails
imports Module
this_mod
= do [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
ie_avails <- forall x y.
(ExportAccum -> x -> TcRn (Maybe (ExportAccum, y)))
-> [x] -> TcRn [y]
accumExports ExportAccum
-> LIE GhcPs -> RnM (Maybe (ExportAccum, (LIE GhcRn, [AvailInfo])))
do_litem [LIE GhcPs]
rdr_items
let final_exports :: [AvailInfo]
final_exports = [AvailInfo] -> [AvailInfo]
nubAvails (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a b. (a, b) -> b
snd [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
ie_avails)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just [(GenLocated SrcSpanAnnA (IE GhcRn), [AvailInfo])]
ie_avails, [AvailInfo]
final_exports)
where
do_litem :: ExportAccum -> LIE GhcPs
-> RnM (Maybe (ExportAccum, (LIE GhcRn, Avails)))
do_litem :: ExportAccum
-> LIE GhcPs -> RnM (Maybe (ExportAccum, (LIE GhcRn, [AvailInfo])))
do_litem ExportAccum
acc LIE GhcPs
lie = forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan (forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
getLocA LIE GhcPs
lie) (ExportAccum
-> LIE GhcPs -> RnM (Maybe (ExportAccum, (LIE GhcRn, [AvailInfo])))
exports_from_item ExportAccum
acc LIE GhcPs
lie)
kids_env :: NameEnv [GlobalRdrElt]
kids_env :: NameEnv [GlobalRdrElt]
kids_env = [GlobalRdrElt] -> NameEnv [GlobalRdrElt]
mkChildEnv (GlobalRdrEnv -> [GlobalRdrElt]
globalRdrEnvElts GlobalRdrEnv
rdr_env)
expand_tyty_gre :: GlobalRdrElt -> [GlobalRdrElt]
expand_tyty_gre :: GlobalRdrElt -> [GlobalRdrElt]
expand_tyty_gre (gre :: GlobalRdrElt
gre@GRE { gre_par :: GlobalRdrElt -> Parent
gre_par = ParentIs Name
p })
| Name -> Bool
isTyConName Name
p, Name -> Bool
isTyConName (GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre) = [GlobalRdrElt
gre, GlobalRdrElt
gre{ gre_par :: Parent
gre_par = Parent
NoParent }]
expand_tyty_gre GlobalRdrElt
gre = [GlobalRdrElt
gre]
imported_modules :: [ModuleName]
imported_modules = [ ImportedModsVal -> ModuleName
imv_name ImportedModsVal
imv
| [ImportedBy]
xs <- forall a. ModuleEnv a -> [a]
moduleEnvElts forall a b. (a -> b) -> a -> b
$ ImportAvails -> ImportedMods
imp_mods ImportAvails
imports
, ImportedModsVal
imv <- [ImportedBy] -> [ImportedModsVal]
importedByUser [ImportedBy]
xs ]
exports_from_item :: ExportAccum -> LIE GhcPs
-> RnM (Maybe (ExportAccum, (LIE GhcRn, Avails)))
exports_from_item :: ExportAccum
-> LIE GhcPs -> RnM (Maybe (ExportAccum, (LIE GhcRn, [AvailInfo])))
exports_from_item (ExportAccum ExportOccMap
occs UniqSet ModuleName
earlier_mods)
(L SrcSpanAnnA
loc ie :: IE GhcPs
ie@(IEModuleContents XIEModuleContents GhcPs
_ lmod :: XRec GhcPs ModuleName
lmod@(L SrcSpanAnnA
_ ModuleName
mod)))
| ModuleName
mod forall a. Uniquable a => a -> UniqSet a -> Bool
`elementOfUniqSet` UniqSet ModuleName
earlier_mods
= do { TcRnMessage -> TcRn ()
addDiagnostic (ModuleName -> TcRnMessage
TcRnDupeModuleExport ModuleName
mod) ;
forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing }
| Bool
otherwise
= do { let { exportValid :: Bool
exportValid = (ModuleName
mod forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ModuleName]
imported_modules)
Bool -> Bool -> Bool
|| (forall unit. GenModule unit -> ModuleName
moduleName Module
this_mod forall a. Eq a => a -> a -> Bool
== ModuleName
mod)
; gre_prs :: [(GlobalRdrElt, GlobalRdrElt)]
gre_prs = ModuleName -> [GlobalRdrElt] -> [(GlobalRdrElt, GlobalRdrElt)]
pickGREsModExp ModuleName
mod (GlobalRdrEnv -> [GlobalRdrElt]
globalRdrEnvElts GlobalRdrEnv
rdr_env)
; new_exports :: [AvailInfo]
new_exports = [ GlobalRdrElt -> AvailInfo
availFromGRE GlobalRdrElt
gre'
| (GlobalRdrElt
gre, GlobalRdrElt
_) <- [(GlobalRdrElt, GlobalRdrElt)]
gre_prs
, GlobalRdrElt
gre' <- GlobalRdrElt -> [GlobalRdrElt]
expand_tyty_gre GlobalRdrElt
gre ]
; all_gres :: [GlobalRdrElt]
all_gres = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(GlobalRdrElt
gre1,GlobalRdrElt
gre2) [GlobalRdrElt]
gres -> GlobalRdrElt
gre1 forall a. a -> [a] -> [a]
: GlobalRdrElt
gre2 forall a. a -> [a] -> [a]
: [GlobalRdrElt]
gres) [] [(GlobalRdrElt, GlobalRdrElt)]
gre_prs
; mods :: UniqSet ModuleName
mods = forall a. Uniquable a => UniqSet a -> a -> UniqSet a
addOneToUniqSet UniqSet ModuleName
earlier_mods ModuleName
mod
}
; Bool -> TcRnMessage -> TcRn ()
checkErr Bool
exportValid (ModuleName -> TcRnMessage
TcRnExportedModNotImported ModuleName
mod)
; Bool -> TcRnMessage -> TcRn ()
warnIf (Bool
exportValid Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(GlobalRdrElt, GlobalRdrElt)]
gre_prs) (ModuleName -> TcRnMessage
TcRnNullExportedModule ModuleName
mod)
; String -> SDoc -> TcRn ()
traceRn String
"efa" (forall a. Outputable a => a -> SDoc
ppr ModuleName
mod SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr [GlobalRdrElt]
all_gres)
; [GlobalRdrElt] -> TcRn ()
addUsedGREs [GlobalRdrElt]
all_gres
; ExportOccMap
occs' <- IE GhcPs -> ExportOccMap -> [AvailInfo] -> RnM ExportOccMap
check_occs IE GhcPs
ie ExportOccMap
occs [AvailInfo]
new_exports
; String -> SDoc -> TcRn ()
traceRn String
"export_mod"
([SDoc] -> SDoc
vcat [ forall a. Outputable a => a -> SDoc
ppr ModuleName
mod
, forall a. Outputable a => a -> SDoc
ppr [AvailInfo]
new_exports ])
; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just ( ExportOccMap -> UniqSet ModuleName -> ExportAccum
ExportAccum ExportOccMap
occs' UniqSet ModuleName
mods
, ( forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall pass.
XIEModuleContents pass -> XRec pass ModuleName -> IE pass
IEModuleContents NoExtField
noExtField XRec GhcPs ModuleName
lmod)
, [AvailInfo]
new_exports))) }
exports_from_item acc :: ExportAccum
acc@(ExportAccum ExportOccMap
occs UniqSet ModuleName
mods) (L SrcSpanAnnA
loc IE GhcPs
ie) = do
Maybe (IE GhcRn)
m_new_ie <- IE GhcPs -> RnM (Maybe (IE GhcRn))
lookup_doc_ie IE GhcPs
ie
case Maybe (IE GhcRn)
m_new_ie of
Just IE GhcRn
new_ie -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (ExportAccum
acc, (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc IE GhcRn
new_ie, [])))
Maybe (IE GhcRn)
Nothing -> do
(IE GhcRn
new_ie, AvailInfo
avail) <- IE GhcPs -> RnM (IE GhcRn, AvailInfo)
lookup_ie IE GhcPs
ie
if Name -> Bool
isUnboundName (forall (p :: Pass). IE (GhcPass p) -> IdP (GhcPass p)
ieName IE GhcRn
new_ie)
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
else do
ExportOccMap
occs' <- IE GhcPs -> ExportOccMap -> [AvailInfo] -> RnM ExportOccMap
check_occs IE GhcPs
ie ExportOccMap
occs [AvailInfo
avail]
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just ( ExportOccMap -> UniqSet ModuleName -> ExportAccum
ExportAccum ExportOccMap
occs' UniqSet ModuleName
mods
, (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc IE GhcRn
new_ie, [AvailInfo
avail])))
lookup_ie :: IE GhcPs -> RnM (IE GhcRn, AvailInfo)
lookup_ie :: IE GhcPs -> RnM (IE GhcRn, AvailInfo)
lookup_ie (IEVar XIEVar GhcPs
_ (L SrcSpanAnnA
l IEWrappedName (IdP GhcPs)
rdr))
= do (Name
name, AvailInfo
avail) <- RdrName -> RnM (Name, AvailInfo)
lookupGreAvailRn forall a b. (a -> b) -> a -> b
$ forall name. IEWrappedName name -> name
ieWrappedName IEWrappedName (IdP GhcPs)
rdr
forall (m :: * -> *) a. Monad m => a -> m a
return (forall pass. XIEVar pass -> LIEWrappedName (IdP pass) -> IE pass
IEVar NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (forall name1 name2.
IEWrappedName name1 -> name2 -> IEWrappedName name2
replaceWrappedName IEWrappedName (IdP GhcPs)
rdr Name
name)), AvailInfo
avail)
lookup_ie (IEThingAbs XIEThingAbs GhcPs
_ (L SrcSpanAnnA
l IEWrappedName (IdP GhcPs)
rdr))
= do (Name
name, AvailInfo
avail) <- RdrName -> RnM (Name, AvailInfo)
lookupGreAvailRn forall a b. (a -> b) -> a -> b
$ forall name. IEWrappedName name -> name
ieWrappedName IEWrappedName (IdP GhcPs)
rdr
forall (m :: * -> *) a. Monad m => a -> m a
return (forall pass.
XIEThingAbs pass -> LIEWrappedName (IdP pass) -> IE pass
IEThingAbs forall a. EpAnn a
noAnn (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (forall name1 name2.
IEWrappedName name1 -> name2 -> IEWrappedName name2
replaceWrappedName IEWrappedName (IdP GhcPs)
rdr Name
name))
, AvailInfo
avail)
lookup_ie ie :: IE GhcPs
ie@(IEThingAll XIEThingAll GhcPs
_ GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
n')
= do
(Located Name
n, [Name]
avail, [FieldLabel]
flds) <- IE GhcPs
-> LIEWrappedName RdrName
-> RnM (Located Name, [Name], [FieldLabel])
lookup_ie_all IE GhcPs
ie GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
n'
let name :: Name
name = forall l e. GenLocated l e -> e
unLoc Located Name
n
forall (m :: * -> *) a. Monad m => a -> m a
return (forall pass.
XIEThingAll pass -> LIEWrappedName (IdP pass) -> IE pass
IEThingAll forall a. EpAnn a
noAnn (forall name1 name2.
LIEWrappedName name1 -> name2 -> LIEWrappedName name2
replaceLWrappedName GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
n' (forall l e. GenLocated l e -> e
unLoc Located Name
n))
, Name -> [Name] -> [FieldLabel] -> AvailInfo
availTC Name
name (Name
nameforall a. a -> [a] -> [a]
:[Name]
avail) [FieldLabel]
flds)
lookup_ie ie :: IE GhcPs
ie@(IEThingWith XIEThingWith GhcPs
_ GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
l IEWildcard
wc [GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))]
sub_rdrs)
= do
(Located Name
lname, [LIEWrappedName Name]
subs, [Name]
avails, [Located FieldLabel]
flds)
<- forall (p :: Pass) a.
OutputableBndrId p =>
IE (GhcPass p) -> TcM a -> TcM a
addExportErrCtxt IE GhcPs
ie forall a b. (a -> b) -> a -> b
$ LIEWrappedName RdrName
-> [LIEWrappedName RdrName]
-> TcM
(Located Name, [LIEWrappedName Name], [Name], [Located FieldLabel])
lookup_ie_with GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
l [GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))]
sub_rdrs
(Located Name
_, [Name]
all_avail, [FieldLabel]
all_flds) <-
case IEWildcard
wc of
IEWildcard
NoIEWildcard -> forall (m :: * -> *) a. Monad m => a -> m a
return (Located Name
lname, [], [])
IEWildcard Int
_ -> IE GhcPs
-> LIEWrappedName RdrName
-> RnM (Located Name, [Name], [FieldLabel])
lookup_ie_all IE GhcPs
ie GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
l
let name :: Name
name = forall l e. GenLocated l e -> e
unLoc Located Name
lname
let flds' :: [Located FieldLabel]
flds' = [Located FieldLabel]
flds forall a. [a] -> [a] -> [a]
++ (forall a b. (a -> b) -> [a] -> [b]
map forall e. e -> Located e
noLoc [FieldLabel]
all_flds)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall pass.
XIEThingWith pass
-> LIEWrappedName (IdP pass)
-> IEWildcard
-> [LIEWrappedName (IdP pass)]
-> IE pass
IEThingWith [Located FieldLabel]
flds' (forall name1 name2.
LIEWrappedName name1 -> name2 -> LIEWrappedName name2
replaceLWrappedName GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
l Name
name) IEWildcard
wc [LIEWrappedName Name]
subs,
Name -> [Name] -> [FieldLabel] -> AvailInfo
availTC Name
name (Name
name forall a. a -> [a] -> [a]
: [Name]
avails forall a. [a] -> [a] -> [a]
++ [Name]
all_avail)
(forall a b. (a -> b) -> [a] -> [b]
map forall l e. GenLocated l e -> e
unLoc [Located FieldLabel]
flds forall a. [a] -> [a] -> [a]
++ [FieldLabel]
all_flds))
lookup_ie IE GhcPs
_ = forall a. String -> a
panic String
"lookup_ie"
lookup_ie_with :: LIEWrappedName RdrName -> [LIEWrappedName RdrName]
-> RnM (Located Name, [LIEWrappedName Name], [Name],
[Located FieldLabel])
lookup_ie_with :: LIEWrappedName RdrName
-> [LIEWrappedName RdrName]
-> TcM
(Located Name, [LIEWrappedName Name], [Name], [Located FieldLabel])
lookup_ie_with (L SrcSpanAnnA
l IEWrappedName RdrName
rdr) [LIEWrappedName RdrName]
sub_rdrs
= do Name
name <- RdrName -> RnM Name
lookupGlobalOccRn forall a b. (a -> b) -> a -> b
$ forall name. IEWrappedName name -> name
ieWrappedName IEWrappedName RdrName
rdr
([LIEWrappedName Name]
non_flds, [Located FieldLabel]
flds) <- Name
-> [LIEWrappedName RdrName]
-> RnM ([LIEWrappedName Name], [Located FieldLabel])
lookupChildrenExport Name
name [LIEWrappedName RdrName]
sub_rdrs
if Name -> Bool
isUnboundName Name
name
then forall (m :: * -> *) a. Monad m => a -> m a
return (forall l e. l -> e -> GenLocated l e
L (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnA
l) Name
name, [], [Name
name], [])
else forall (m :: * -> *) a. Monad m => a -> m a
return (forall l e. l -> e -> GenLocated l e
L (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnA
l) Name
name, [LIEWrappedName Name]
non_flds
, forall a b. (a -> b) -> [a] -> [b]
map (forall name. IEWrappedName name -> name
ieWrappedName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc) [LIEWrappedName Name]
non_flds
, [Located FieldLabel]
flds)
lookup_ie_all :: IE GhcPs -> LIEWrappedName RdrName
-> RnM (Located Name, [Name], [FieldLabel])
lookup_ie_all :: IE GhcPs
-> LIEWrappedName RdrName
-> RnM (Located Name, [Name], [FieldLabel])
lookup_ie_all IE GhcPs
ie (L SrcSpanAnnA
l IEWrappedName RdrName
rdr) =
do Name
name <- RdrName -> RnM Name
lookupGlobalOccRn forall a b. (a -> b) -> a -> b
$ forall name. IEWrappedName name -> name
ieWrappedName IEWrappedName RdrName
rdr
let gres :: [GlobalRdrElt]
gres = forall a. NameEnv [a] -> Name -> [a]
findChildren NameEnv [GlobalRdrElt]
kids_env Name
name
([Name]
non_flds, [FieldLabel]
flds) = [GlobalRdrElt] -> ([Name], [FieldLabel])
classifyGREs [GlobalRdrElt]
gres
RdrName -> [GlobalRdrElt] -> TcRn ()
addUsedKids (forall name. IEWrappedName name -> name
ieWrappedName IEWrappedName RdrName
rdr) [GlobalRdrElt]
gres
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [GlobalRdrElt]
gres) forall a b. (a -> b) -> a -> b
$
if Name -> Bool
isTyConName Name
name
then TcRnMessage -> TcRn ()
addTcRnDiagnostic (Name -> TcRnMessage
TcRnDodgyExports Name
name)
else
TcRnMessage -> TcRn ()
addErr (IE GhcPs -> TcRnMessage
TcRnExportHiddenComponents IE GhcPs
ie)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall l e. l -> e -> GenLocated l e
L (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnA
l) Name
name, [Name]
non_flds, [FieldLabel]
flds)
lookup_doc_ie :: IE GhcPs -> RnM (Maybe (IE GhcRn))
lookup_doc_ie :: IE GhcPs -> RnM (Maybe (IE GhcRn))
lookup_doc_ie (IEGroup XIEGroup GhcPs
_ Int
lev LHsDoc GhcPs
doc) = do
LHsDoc GhcRn
doc' <- LHsDoc GhcPs -> RnM (LHsDoc GhcRn)
rnLHsDoc LHsDoc GhcPs
doc
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (forall pass. XIEGroup pass -> Int -> LHsDoc pass -> IE pass
IEGroup NoExtField
noExtField Int
lev LHsDoc GhcRn
doc')
lookup_doc_ie (IEDoc XIEDoc GhcPs
_ LHsDoc GhcPs
doc) = do
LHsDoc GhcRn
doc' <- LHsDoc GhcPs -> RnM (LHsDoc GhcRn)
rnLHsDoc LHsDoc GhcPs
doc
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (forall pass. XIEDoc pass -> LHsDoc pass -> IE pass
IEDoc NoExtField
noExtField LHsDoc GhcRn
doc')
lookup_doc_ie (IEDocNamed XIEDocNamed GhcPs
_ String
str) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (forall pass. XIEDocNamed pass -> String -> IE pass
IEDocNamed NoExtField
noExtField String
str)
lookup_doc_ie IE GhcPs
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing
addUsedKids :: RdrName -> [GlobalRdrElt] -> RnM ()
addUsedKids :: RdrName -> [GlobalRdrElt] -> TcRn ()
addUsedKids RdrName
parent_rdr [GlobalRdrElt]
kid_gres = [GlobalRdrElt] -> TcRn ()
addUsedGREs (RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
pickGREs RdrName
parent_rdr [GlobalRdrElt]
kid_gres)
classifyGREs :: [GlobalRdrElt] -> ([Name], [FieldLabel])
classifyGREs :: [GlobalRdrElt] -> ([Name], [FieldLabel])
classifyGREs = [GreName] -> ([Name], [FieldLabel])
partitionGreNames forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> GreName
gre_name
lookupChildrenExport :: Name -> [LIEWrappedName RdrName]
-> RnM ([LIEWrappedName Name], [Located FieldLabel])
lookupChildrenExport :: Name
-> [LIEWrappedName RdrName]
-> RnM ([LIEWrappedName Name], [Located FieldLabel])
lookupChildrenExport Name
spec_parent [LIEWrappedName RdrName]
rdr_items =
do
[Either (LIEWrappedName Name) (Located FieldLabel)]
xs <- forall a b. (a -> TcRn b) -> [a] -> TcRn [b]
mapAndReportM LIEWrappedName RdrName
-> RnM (Either (LIEWrappedName Name) (Located FieldLabel))
doOne [LIEWrappedName RdrName]
rdr_items
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. [Either a b] -> ([a], [b])
partitionEithers [Either (LIEWrappedName Name) (Located FieldLabel)]
xs
where
choosePossibleNamespaces :: NameSpace -> [NameSpace]
choosePossibleNamespaces :: NameSpace -> [NameSpace]
choosePossibleNamespaces NameSpace
ns
| NameSpace
ns forall a. Eq a => a -> a -> Bool
== NameSpace
varName = [NameSpace
varName, NameSpace
tcName]
| NameSpace
ns forall a. Eq a => a -> a -> Bool
== NameSpace
tcName = [NameSpace
dataName, NameSpace
tcName]
| Bool
otherwise = [NameSpace
ns]
doOne :: LIEWrappedName RdrName
-> RnM (Either (LIEWrappedName Name) (Located FieldLabel))
doOne :: LIEWrappedName RdrName
-> RnM (Either (LIEWrappedName Name) (Located FieldLabel))
doOne LIEWrappedName RdrName
n = do
let bareName :: RdrName
bareName = (forall name. IEWrappedName name -> name
ieWrappedName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc) LIEWrappedName RdrName
n
lkup :: NameSpace -> RnM ChildLookupResult
lkup NameSpace
v = Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
lookupSubBndrOcc_helper Bool
False Bool
True
Name
spec_parent (RdrName -> NameSpace -> RdrName
setRdrNameSpace RdrName
bareName NameSpace
v)
ChildLookupResult
name <- [RnM ChildLookupResult] -> RnM ChildLookupResult
combineChildLookupResult forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map NameSpace -> RnM ChildLookupResult
lkup forall a b. (a -> b) -> a -> b
$
NameSpace -> [NameSpace]
choosePossibleNamespaces (RdrName -> NameSpace
rdrNameSpace RdrName
bareName)
String -> SDoc -> TcRn ()
traceRn String
"lookupChildrenExport" (forall a. Outputable a => a -> SDoc
ppr ChildLookupResult
name)
let unboundName :: RdrName
unboundName :: RdrName
unboundName = if RdrName -> NameSpace
rdrNameSpace RdrName
bareName forall a. Eq a => a -> a -> Bool
== NameSpace
varName
then RdrName
bareName
else RdrName -> NameSpace -> RdrName
setRdrNameSpace RdrName
bareName NameSpace
dataName
case ChildLookupResult
name of
ChildLookupResult
NameNotFound -> do { Name
ub <- RdrName -> RnM Name
reportUnboundName RdrName
unboundName
; let l :: SrcSpanAnnA
l = forall l e. GenLocated l e -> l
getLoc LIEWrappedName RdrName
n
; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (forall name. LocatedN name -> IEWrappedName name
IEName (forall l e. l -> e -> GenLocated l e
L (forall a. SrcSpanAnn' a -> SrcSpanAnnN
la2na SrcSpanAnnA
l) Name
ub))))}
FoundChild Parent
par GreName
child -> do { Name -> Parent -> GreName -> TcRn ()
checkPatSynParent Name
spec_parent Parent
par GreName
child
; forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case GreName
child of
FieldGreName FieldLabel
fl -> forall a b. b -> Either a b
Right (forall l e. l -> e -> GenLocated l e
L (forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
getLocA LIEWrappedName RdrName
n) FieldLabel
fl)
NormalGreName Name
name -> forall a b. a -> Either a b
Left (forall name1 name2.
LIEWrappedName name1 -> name2 -> LIEWrappedName name2
replaceLWrappedName LIEWrappedName RdrName
n Name
name)
}
IncorrectParent Name
p GreName
c [Name]
gs -> forall a. Name -> GreName -> [Name] -> TcM a
failWithDcErr Name
p GreName
c [Name]
gs
checkPatSynParent :: Name
-> Parent
-> GreName
-> TcM ()
checkPatSynParent :: Name -> Parent -> GreName -> TcRn ()
checkPatSynParent Name
_ (ParentIs {}) GreName
_
= forall (m :: * -> *) a. Monad m => a -> m a
return ()
checkPatSynParent Name
parent Parent
NoParent GreName
gname
| Name -> Bool
isUnboundName Name
parent
= forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise
= do { TyCon
parent_ty_con <- Name -> TcM TyCon
tcLookupTyCon Name
parent
; TyThing
mpat_syn_thing <- Name -> TcM TyThing
tcLookupGlobal (GreName -> Name
greNameMangledName GreName
gname)
; case TyThing
mpat_syn_thing of
AnId Id
i | Id -> Bool
isId Id
i
, RecSelId { sel_tycon :: IdDetails -> RecSelParent
sel_tycon = RecSelPatSyn PatSyn
p } <- Id -> IdDetails
idDetails Id
i
-> SDoc -> TyCon -> PatSyn -> TcRn ()
handle_pat_syn (GreName -> SDoc
selErr GreName
gname) TyCon
parent_ty_con PatSyn
p
AConLike (PatSynCon PatSyn
p) -> SDoc -> TyCon -> PatSyn -> TcRn ()
handle_pat_syn (PatSyn -> SDoc
psErr PatSyn
p) TyCon
parent_ty_con PatSyn
p
TyThing
_ -> forall a. Name -> GreName -> [Name] -> TcM a
failWithDcErr Name
parent GreName
gname [] }
where
psErr :: PatSyn -> SDoc
psErr = forall o. Outputable o => String -> o -> SDoc
exportErrCtxt String
"pattern synonym"
selErr :: GreName -> SDoc
selErr = forall o. Outputable o => String -> o -> SDoc
exportErrCtxt String
"pattern synonym record selector"
handle_pat_syn :: SDoc
-> TyCon
-> PatSyn
-> TcM ()
handle_pat_syn :: SDoc -> TyCon -> PatSyn -> TcRn ()
handle_pat_syn SDoc
doc TyCon
ty_con PatSyn
pat_syn
| Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ TyCon -> Bool
isTyConWithSrcDataCons TyCon
ty_con
= forall a. SDoc -> TcM a -> TcM a
addErrCtxt SDoc
doc forall a b. (a -> b) -> a -> b
$ forall a. TcRnMessage -> TcM a
failWithTc TcRnMessage
TcRnPatSynBundledWithNonDataCon
| Maybe TyCon
Nothing <- Maybe TyCon
mtycon
= forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Just TyCon
p_ty_con <- Maybe TyCon
mtycon, TyCon
p_ty_con forall a. Eq a => a -> a -> Bool
/= TyCon
ty_con
= forall a. SDoc -> TcM a -> TcM a
addErrCtxt SDoc
doc forall a b. (a -> b) -> a -> b
$ forall a. TcRnMessage -> TcM a
failWithTc
(Type -> Type -> TcRnMessage
TcRnPatSynBundledWithWrongType Type
expected_res_ty Type
res_ty)
| Bool
otherwise
= forall (m :: * -> *) a. Monad m => a -> m a
return ()
where
expected_res_ty :: Type
expected_res_ty = TyCon -> [Type] -> Type
mkTyConApp TyCon
ty_con ([Id] -> [Type]
mkTyVarTys (TyCon -> [Id]
tyConTyVars TyCon
ty_con))
([Id]
_, [Type]
_, [Id]
_, [Type]
_, [Scaled Type]
_, Type
res_ty) = PatSyn -> ([Id], [Type], [Id], [Type], [Scaled Type], Type)
patSynSig PatSyn
pat_syn
mtycon :: Maybe TyCon
mtycon = forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack => Type -> Maybe (TyCon, [Type])
tcSplitTyConApp_maybe Type
res_ty
check_occs :: IE GhcPs -> ExportOccMap -> [AvailInfo]
-> RnM ExportOccMap
check_occs :: IE GhcPs -> ExportOccMap -> [AvailInfo] -> RnM ExportOccMap
check_occs IE GhcPs
ie ExportOccMap
occs [AvailInfo]
avails
= forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM ExportOccMap -> GreName -> RnM ExportOccMap
check ExportOccMap
occs [GreName]
children
where
children :: [GreName]
children = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap AvailInfo -> [GreName]
availGreNames [AvailInfo]
avails
check :: ExportOccMap -> GreName -> RnM ExportOccMap
check :: ExportOccMap -> GreName -> RnM ExportOccMap
check ExportOccMap
occs GreName
child
= case ExportOccMap -> GreName -> Either (GreName, IE GhcPs) ExportOccMap
try_insert ExportOccMap
occs GreName
child of
Right ExportOccMap
occs' -> forall (m :: * -> *) a. Monad m => a -> m a
return ExportOccMap
occs'
Left (GreName
child', IE GhcPs
ie')
| GreName -> Name
greNameMangledName GreName
child forall a. Eq a => a -> a -> Bool
== GreName -> Name
greNameMangledName GreName
child'
-> do { Bool -> TcRnMessage -> TcRn ()
warnIf (Bool -> Bool
not (GreName -> IE GhcPs -> IE GhcPs -> Bool
dupExport_ok GreName
child IE GhcPs
ie IE GhcPs
ie')) (GreName -> IE GhcPs -> IE GhcPs -> TcRnMessage
TcRnDuplicateExport GreName
child IE GhcPs
ie IE GhcPs
ie')
; forall (m :: * -> *) a. Monad m => a -> m a
return ExportOccMap
occs }
| Bool
otherwise
-> do { GlobalRdrEnv
global_env <- TcRn GlobalRdrEnv
getGlobalRdrEnv ;
TcRnMessage -> TcRn ()
addErr (GlobalRdrEnv
-> GreName -> GreName -> IE GhcPs -> IE GhcPs -> TcRnMessage
exportClashErr GlobalRdrEnv
global_env GreName
child' GreName
child IE GhcPs
ie' IE GhcPs
ie) ;
forall (m :: * -> *) a. Monad m => a -> m a
return ExportOccMap
occs }
try_insert :: ExportOccMap -> GreName -> Either (GreName, IE GhcPs) ExportOccMap
try_insert :: ExportOccMap -> GreName -> Either (GreName, IE GhcPs) ExportOccMap
try_insert ExportOccMap
occs GreName
child
= case forall a. OccEnv a -> OccName -> Maybe a
lookupOccEnv ExportOccMap
occs OccName
name_occ of
Maybe (GreName, IE GhcPs)
Nothing -> forall a b. b -> Either a b
Right (forall a. OccEnv a -> OccName -> a -> OccEnv a
extendOccEnv ExportOccMap
occs OccName
name_occ (GreName
child, IE GhcPs
ie))
Just (GreName, IE GhcPs)
x -> forall a b. a -> Either a b
Left (GreName, IE GhcPs)
x
where
name_occ :: OccName
name_occ = Name -> OccName
nameOccName (GreName -> Name
greNameMangledName GreName
child)
dupExport_ok :: GreName -> IE GhcPs -> IE GhcPs -> Bool
dupExport_ok :: GreName -> IE GhcPs -> IE GhcPs -> Bool
dupExport_ok GreName
child IE GhcPs
ie1 IE GhcPs
ie2
= Bool -> Bool
not ( forall {pass}. IE pass -> Bool
single IE GhcPs
ie1 Bool -> Bool -> Bool
|| forall {pass}. IE pass -> Bool
single IE GhcPs
ie2
Bool -> Bool -> Bool
|| (IE GhcPs -> Bool
explicit_in IE GhcPs
ie1 Bool -> Bool -> Bool
&& IE GhcPs -> Bool
explicit_in IE GhcPs
ie2) )
where
explicit_in :: IE GhcPs -> Bool
explicit_in (IEModuleContents {}) = Bool
False
explicit_in (IEThingAll XIEThingAll GhcPs
_ GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
r)
= forall name. HasOccName name => name -> OccName
occName GreName
child forall a. Eq a => a -> a -> Bool
== RdrName -> OccName
rdrNameOcc (forall name. IEWrappedName name -> name
ieWrappedName forall a b. (a -> b) -> a -> b
$ forall l e. GenLocated l e -> e
unLoc GenLocated SrcSpanAnnA (IEWrappedName (IdP GhcPs))
r)
explicit_in IE GhcPs
_ = Bool
True
single :: IE pass -> Bool
single IEVar {} = Bool
True
single IEThingAbs {} = Bool
True
single IE pass
_ = Bool
False
exportErrCtxt :: Outputable o => String -> o -> SDoc
exportErrCtxt :: forall o. Outputable o => String -> o -> SDoc
exportErrCtxt String
herald o
exp =
String -> SDoc
text String
"In the" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text (String
herald forall a. [a] -> [a] -> [a]
++ String
":") SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr o
exp
addExportErrCtxt :: (OutputableBndrId p)
=> IE (GhcPass p) -> TcM a -> TcM a
addExportErrCtxt :: forall (p :: Pass) a.
OutputableBndrId p =>
IE (GhcPass p) -> TcM a -> TcM a
addExportErrCtxt IE (GhcPass p)
ie = forall a. SDoc -> TcM a -> TcM a
addErrCtxt SDoc
exportCtxt
where
exportCtxt :: SDoc
exportCtxt = String -> SDoc
text String
"In the export:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr IE (GhcPass p)
ie
failWithDcErr :: Name -> GreName -> [Name] -> TcM a
failWithDcErr :: forall a. Name -> GreName -> [Name] -> TcM a
failWithDcErr Name
parent GreName
child [Name]
parents = do
TyThing
ty_thing <- Name -> TcM TyThing
tcLookupGlobal (GreName -> Name
greNameMangledName GreName
child)
forall a. TcRnMessage -> TcM a
failWithTc forall a b. (a -> b) -> a -> b
$ Name -> TyThing -> GreName -> [Name] -> TcRnMessage
TcRnExportedParentChildMismatch Name
parent TyThing
ty_thing GreName
child [Name]
parents
exportClashErr :: GlobalRdrEnv
-> GreName -> GreName
-> IE GhcPs -> IE GhcPs
-> TcRnMessage
exportClashErr :: GlobalRdrEnv
-> GreName -> GreName -> IE GhcPs -> IE GhcPs -> TcRnMessage
exportClashErr GlobalRdrEnv
global_env GreName
child1 GreName
child2 IE GhcPs
ie1 IE GhcPs
ie2
= OccName
-> GreName
-> GlobalRdrElt
-> IE GhcPs
-> GreName
-> GlobalRdrElt
-> IE GhcPs
-> TcRnMessage
TcRnConflictingExports OccName
occ GreName
child1' GlobalRdrElt
gre1' IE GhcPs
ie1' GreName
child2' GlobalRdrElt
gre2' IE GhcPs
ie2'
where
occ :: OccName
occ = forall name. HasOccName name => name -> OccName
occName GreName
child1
gre1 :: GlobalRdrElt
gre1 = GreName -> GlobalRdrElt
get_gre GreName
child1
gre2 :: GlobalRdrElt
gre2 = GreName -> GlobalRdrElt
get_gre GreName
child2
get_gre :: GreName -> GlobalRdrElt
get_gre GreName
child
= forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"exportClashErr" (forall a. Outputable a => a -> SDoc
ppr GreName
child))
(GlobalRdrEnv -> GreName -> Maybe GlobalRdrElt
lookupGRE_GreName GlobalRdrEnv
global_env GreName
child)
(GreName
child1', GlobalRdrElt
gre1', IE GhcPs
ie1', GreName
child2', GlobalRdrElt
gre2', IE GhcPs
ie2') =
case SrcSpan -> SrcSpan -> Ordering
SrcLoc.leftmost_smallest (GlobalRdrElt -> SrcSpan
greSrcSpan GlobalRdrElt
gre1) (GlobalRdrElt -> SrcSpan
greSrcSpan GlobalRdrElt
gre2) of
Ordering
LT -> (GreName
child1, GlobalRdrElt
gre1, IE GhcPs
ie1, GreName
child2, GlobalRdrElt
gre2, IE GhcPs
ie2)
Ordering
GT -> (GreName
child2, GlobalRdrElt
gre2, IE GhcPs
ie2, GreName
child1, GlobalRdrElt
gre1, IE GhcPs
ie1)
Ordering
EQ -> forall a. String -> a
panic String
"exportClashErr: clashing exports have idential location"